GREEN = (0, 255, 0) BLUE = (0, 0, 255) CAR_RECT = Rect(0, 0, 5, 5) if __name__ == '__main__': SIMULATOR = Simulator([ vec(50, 40), vec(100, 44), vec(300, 36), vec(450, 40), vec(50, 160), vec(100, 180), vec(200, 160), vec(450, 160), vec(200, 10), vec(200, 40), vec(150, 172), vec(200, 400) ], [ [1], [9], [3], [7], [5], [10], [7], [11], [9], [10, 2], [11, 6], [7, 10, 6] ], { 0: TrafficLight(2, 1, 2), 1: TrafficLight(2, 1, 2), 2: TrafficLight(2, 1, 2), 3: TrafficLight(2, 1, 2), 4: TrafficLight(2, 1, 2), 5: TrafficLight(2, 1, 2), 6: TrafficLight(2, 1, 2) }, [ (vec(70, 200), 1, 4) ]) SIMULATOR.createCar(Thinker(), 0) SIMULATOR.createCar(Thinker(), 1) # initialize pygame and create window pygame.init()
import json from simulator.hero import all_heroes from simulator.simulator import Simulator #hero1 = all_heroes["Nino"] #hero2 = all_heroes["Lucina"] hero1 = all_heroes["Robin (M)"] hero2 = all_heroes["Takumi"] #hero1.stats.attack = 20 #hero2.stats.attack = 20 print(hero1) print(hero1.stats) print(hero1.skills) print() print(hero2) print(hero2.stats) print(hero2.skills) print() print() sim = Simulator(hero1, hero2) sim.run() print() print() sim = Simulator(hero2, hero1) sim.run()
import numpy as np from simulator.drone import Drone from simulator.controller import Controller from simulator.simulator import Simulator if __name__ == '__main__': drone = Drone() controller = Controller(drone) # Simulate some disturbance in the angular velocity. angular_disturbance = np.array([[0.0], [0.0], [0.0]]) drone.thetadot = angular_disturbance simulator = Simulator(drone, controller) simulator.simulate(30) # simulate n secs
def __init__(self, num_nodes): #: Cluster configuration self.NUM_NODES = num_nodes # node_id: 0,1,2,... #: fixed 9 apps self.NUM_APPS = 7 #: initialized state to zero matrix self._state_reset() # clustering self.baisc_oath_name = 'subScheduler_' path_surffix = "./checkpoint/" self.subScheduler_api_0 = subScheduler(path_name=self.baisc_oath_name + '0', surffix='0', path_surffix=path_surffix) self.subScheduler_api_1 = subScheduler(path_name=self.baisc_oath_name + '10', surffix='10', path_surffix=path_surffix) self.subScheduler_api_2 = subScheduler(path_name=self.baisc_oath_name + '20', surffix='20', path_surffix=path_surffix) self.subScheduler_api_3 = subScheduler(path_name=self.baisc_oath_name + '30', surffix='30', path_surffix=path_surffix) self.subScheduler_api_4 = subScheduler(path_name=self.baisc_oath_name + '40', surffix='40', path_surffix=path_surffix) self.subScheduler_api_5 = subScheduler(path_name=self.baisc_oath_name + '50', surffix='50', path_surffix=path_surffix) self.subScheduler_api_6 = subScheduler(path_name=self.baisc_oath_name + '60', surffix='60', path_surffix=path_surffix) self.subScheduler_api_7 = subScheduler(path_name=self.baisc_oath_name + '70', surffix='70', path_surffix=path_surffix) self.subScheduler_api_8 = subScheduler(path_name=self.baisc_oath_name + '80', surffix='80', path_surffix=path_surffix) self.subScheduler_api_9 = subScheduler(path_name=self.baisc_oath_name + '90', surffix='90', path_surffix=path_surffix) self.subScheduler_api_10 = subScheduler( path_name=self.baisc_oath_name + '100', surffix='100', path_surffix=path_surffix) self.subScheduler_api_11 = subScheduler( path_name=self.baisc_oath_name + '110', surffix='110', path_surffix=path_surffix) self.subScheduler_api_12 = subScheduler( path_name=self.baisc_oath_name + '120', surffix='120', path_surffix=path_surffix) self.subScheduler_api_13 = subScheduler( path_name=self.baisc_oath_name + '130', surffix='130', path_surffix=path_surffix) self.subScheduler_api_14 = subScheduler( path_name=self.baisc_oath_name + '140', surffix='140', path_surffix=path_surffix) self.subScheduler_api_15 = subScheduler( path_name=self.baisc_oath_name + '150', surffix='150', path_surffix=path_surffix) self.subScheduler_api_16 = subScheduler( path_name=self.baisc_oath_name + '160', surffix='160', path_surffix=path_surffix) self.subScheduler_api_17 = subScheduler( path_name=self.baisc_oath_name + '170', surffix='170', path_surffix=path_surffix) self.subScheduler_api_18 = subScheduler( path_name=self.baisc_oath_name + '180', surffix='180', path_surffix=path_surffix) self.subScheduler_api_19 = subScheduler( path_name=self.baisc_oath_name + '190', surffix='190', path_surffix=path_surffix) self.sim = Simulator()
sys.exit(1) total_num_leader_msg = 0 total_orig_num_leader_msg = 0 total_num_pos_msg = 0 total_valid_time = 0 total_avg_cvg_time = 0 total_max_cvg_time = 0 total_num_leader_changes = 0 for _ in range(cmd_args.trials): sim = Simulator( rm, #route manager algo, #algorithm module connec, "simulator/maps", #map folder visual= False, # set to True if need to visually observe the simulation new_route= True # set to True if not need to re-generate vehicle routes ) rm.bind_simulator(sim) sim.start_simulation() num_leader_msg = sim.get_count("leader_msg") num_orig_leader_msg = sim.get_count("original_leader_msg") num_pos_msg = sim.get_count("pos_msg") valid_time = sim.get_valid_time() avg_cvg_time = sim.get_avg_cvg_time() max_cvg_time = sim.get_max_cvg_time() num_leader_changes = sim.get_nbr_leader_changes()
class LraClusterEnv(): def __init__(self, num_nodes, ifSimulator=True): #: Cluster configuration self.NUM_NODES = num_nodes # TODO: heterogeneous cluster self.NUM_APPS = 7 self._state_reset() if ifSimulator: self.sim = Simulator() def _state_reset(self): self.state = np.zeros([self.NUM_NODES, self.NUM_APPS]) def reset(self): self._state_reset() return self._get_state() def step(self, action, appid): """ :param action: node chosen :param appid: current app_id of the container to be allocated :return: new state after allocation """ curr_app = appid self.state[action][curr_app] += 1 # locate state = self._get_state() return state def _get_state(self): return self.state @property def _get_throughput_predictor(self): # testbed: using predictor return self.state def get_all_node_throughput(self): node_tput_list = [] for nid in range(self.NUM_NODES): state_this_node = self.state[nid] tput_this_node = ( self.sim.predict(state_this_node.reshape(1, -1)) * state_this_node).sum() node_tput_list.append(tput_this_node) return sum(node_tput_list) def get_tput_total_env(self): return self._get_throughput_predictor def _create_preference(self): from scipy.sparse import diags # cardinality of application itself # a b c d e f g h i # - 2 i i - 2 2 i - # -: cardinality == negative, i.e., anti-affinity # 2: cardinality == 2, if 1 < num <= cardinality, +50%, if num > cardinality, -50% # i: cardinatliy == infinity, i.e., affinity preference = diags([-1, 2, np.inf, np.inf, -1, 2, 2, np.inf, -1]).todense() # cardinality of application # -: abc, def, ghi # i: adg, beh, cfi # 2: af, di # 5: cd, fg # 0: others neg_group = [[0, 1, 2], [3, 4, 5], [6, 7, 8]] inf_group = [[0, 3, 6], [1, 4, 7], [2, 5, 8]] two_group = [[0, 5], [3, 8]] fiv_group = [[2, 3], [5, 6]] def assign_preference(pre, group, value): for g in group: length = len(g) for temp_i in range(length): a = g[temp_i] for temp_j in range(length): if temp_i != temp_j: b = g[temp_j] pre[a, b] = value pre[b, a] = value return pre preference = assign_preference(preference, neg_group, -1) preference = assign_preference(preference, inf_group, np.inf) preference = assign_preference(preference, two_group, 2) preference = assign_preference(preference, fiv_group, 5) preference = np.array(preference) # necessary. """ Simulation: 9 nodes, 9 Apps, 81 containers Preference: [[-1. -1. -1. inf 0. 2. inf 0. 0.] [-1. 2. -1. 0. inf 0. 0. inf 0.] [-1. -1. inf 5. 0. inf 0. 0. inf] [inf 0. 5. inf -1. -1. inf 0. 2.] [ 0. inf 0. -1. -1. -1. 0. inf 0.] [ 2. 0. inf -1. -1. 2. 5. 0. inf] [inf 0. 0. inf 0. 5. 2. -1. -1.] [ 0. inf 0. 0. inf 0. -1. inf -1.] [ 0. 0. inf 2. 0. inf -1. -1. -1.]] # -: abc, def, ghi # i: adg, beh, cfi # 2: af, di # 5: cd, fg # 0: others """ return preference def get_throughput_single_node(self, nid): state_this_node = self.state[nid] # TODO: we could change sum() to mean(), if using latency tput_this_node = (self.sim.predict(state_this_node.reshape(1, -1)) * state_this_node).sum() return tput_this_node, self.sim.predict(state_this_node.reshape(1, -1)) def get_throughput_given_state(self, container_list): state_this_node = np.array(container_list) tput_this_node = (self.sim.predict(state_this_node.reshape(1, -1)) * state_this_node).sum() return tput_this_node, self.sim.predict(state_this_node.reshape(1, -1))
def __label_single_maps(self, atlas_name, feature_list: List[str], label_list: List[str], single_feature_list: List[str], single_label_list: List[str], overwrite: bool) -> List[Dict[str, any]]: """ Passed atlas name, feature list, label list, and returns res object with the map features labelled for training """ if not atlas_name: return [] if not overwrite and self.__services.resources.training_data_dir.exists( "training_" + atlas_name, ".pickle"): self.__services.debug.write( "Found in training data. Loading from training data", DebugLevel.BASIC) return self.__services.resources.training_data_dir.load( "training_" + atlas_name) self.__services.debug.write("Loading maps", DebugLevel.BASIC) maps: List[Map] = self.__services.resources.maps_dir.get_atlas( atlas_name).load_all() res: List[Dict[str, any]] = [] progress_bar: Progress = self.__services.debug.progress_debug( len(maps), DebugLevel.BASIC) progress_bar.start() # process atlas for m in maps: config = Configuration() config.simulator_algorithm_type = AStar config.simulator_testing_type = AStarTesting config.simulator_initial_map = m services: Services = Services(config) simulator: Simulator = Simulator(services) testing: AStarTesting = simulator.start() features: Dict[str, any] = {} arg: str for arg in [ "map_obstacles_percentage", "goal_found", "distance_to_goal", "original_distance_to_goal", "trace", "total_steps", "total_distance", "smoothness_of_trajectory", "total_time", "algorithm_type", "fringe", "search_space" ]: features[arg] = testing.get_results()[arg] features["features"] = MapProcessing.get_sequential_features( testing.map, feature_list) features["labels"] = MapProcessing.get_sequential_labels( testing.map, label_list) features["single_features"] = MapProcessing.get_single_features( m, single_feature_list) features["single_labels"] = MapProcessing.get_single_labels( m, single_label_list) res.append(features) progress_bar.step() return res
def test_simulator_initialized_correct_state(): simulator = Simulator(5, 5) assert simulator.get_board_size() == [5, 5]
def __init__(self, start_time, timestep, dispatch_policy, matching_policy): self.simulator = Simulator(start_time, timestep) self.agent = Agent(dispatch_policy, matching_policy) self.last_vehicle_id = 1 self.vehicle_queue = []
from functions.TEMA import TEMAdecision from functions.TRIMA import TRIMAdecision from functions.WMA import WMAdecision from simulator.simulator import Simulator import pandas_datareader as web import pandas as pd import datetime as dt start = dt.datetime(2015, 1, 1) end = dt.datetime(2017, 12, 31) asset = 'AAPL' data = web.DataReader(asset, 'morningstar', start=start, end=end) data.index = data.index.droplevel() sim = Simulator(data, std_purchase=10) sim.add_indicator('EMA-20', EMAdecision(data, 20)) sim.add_indicator('KAMA-20', KAMAdecision(data, 20)) sim.add_indicator('SMA-20', SMAdecision(data, 20)) sim.add_indicator('SMA-100', SMAdecision(data, 10)) sim.add_indicator('TEMA-20', TEMAdecision(data, 20)) sim.add_indicator('TRIMA-20', TRIMAdecision(data, 20)) sim.add_indicator('WMA-20', WMAdecision(data, 20)) #print(sim.security.head()) #print(sim.security.tail()) sim.calc_earning() print('\n Resumen') print('Capital final {}'.format(sim.final_capital)) print('Acciones finales {}'.format(sim.shares_own))
class Experiment(object): def __init__(self, start_time, timestep, dispatch_policy, matching_policy): self.simulator = Simulator(start_time, timestep) self.agent = Agent(dispatch_policy, matching_policy) self.last_vehicle_id = 1 self.vehicle_queue = [] def reset(self, start_time=None, timestep=None): # self.simulator.log_score() self.simulator.reset(start_time, timestep) def populate_vehicles(self, vehicle_locations): n_vehicles = len(vehicle_locations) vehicle_ids = range(self.last_vehicle_id, self.last_vehicle_id + n_vehicles) self.last_vehicle_id += n_vehicles # locations = [mesh.convert_xy_to_lonlat(x, y)[::-1] for x in range(MAP_WIDTH) for y in range(MAP_HEIGHT)] # p = sum(self.dummy_agent.dispatch_policy.demand_predictor.predict(self.simulator.get_current_time())[0]) # p = p.flatten() / p.sum() # vehicle_locations = [locations[i] for i in np.random.choice(len(locations), size=n_vehicles, p=p)] t = self.simulator.get_current_time() entering_time = np.random.uniform(t, t + ENTERING_TIME_BUFFER, n_vehicles).tolist() q = sorted(zip(entering_time, vehicle_ids, vehicle_locations)) self.vehicle_queue = q def enter_market(self): t = self.simulator.get_current_time() while self.vehicle_queue: t_enter, vehicle_id, location = self.vehicle_queue[0] if t >= t_enter: self.vehicle_queue.pop(0) self.simulator.populate_vehicle(vehicle_id, location) else: break def step(self, verbose=False): self.enter_market() self.simulator.step() vehicles = self.simulator.get_vehicles_state() requests = self.simulator.get_new_requests() # print("R: ", len(requests)) current_time = self.simulator.get_current_time() m_commands, d_commands = self.agent.get_commands(current_time, vehicles, requests) self.simulator.match_vehicles(m_commands) self.simulator.dispatch_vehicles(d_commands) net_v = vehicles[vehicles.status != status_codes.V_OFF_DUTY] if len(m_commands) > 0: average_wt = np.mean([command['duration'] for command in m_commands]).astype(int) else: average_wt = 0 summary = "{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}".format( current_time, len(net_v), len(net_v[net_v.status == status_codes.V_OCCUPIED]), len(requests), len(m_commands), len(d_commands), average_wt ) sim_logger.log_summary(summary) if verbose: print("summary: ({})".format(summary), flush=True) def dry_run(self, n_steps): for _ in range(n_steps): self.simulator.step()
def run_graphical_for(self, ticks): s = Simulator(self.nodes) s.run_graphical(ticks)
def run_for(self, ticks): s = Simulator(self.nodes) s.run(ticks)
# '0_1d4480abe9aa45ce51a99c0e19a8a54', '1_1d4480abe9aa45ce51a99c0e19a8a54', '2_1d4480abe9aa45ce51a99c0e19a8a54', # '3_1d4480abe9aa45ce51a99c0e19a8a54', '4_1d4480abe9aa45ce51a99c0e19a8a54', '1_1d9b04c979dfbddca84874d9f682ce6c', # '2_1d9b04c979dfbddca84874d9f682ce6c', '4_1d9b04c979dfbddca84874d9f682ce6c', '0_1b370d5326cb7da75318625c74026d6', # '1_1b370d5326cb7da75318625c74026d6', '3_1b370d5326cb7da75318625c74026d6', '4_1b370d5326cb7da75318625c74026d6', # '0_3b947648cfb77c92dc6e31f308657eca', '3_3b947648cfb77c92dc6e31f308657eca', '1_1e23d88e517b711567ff608a5fbe6aa8']) scenes = scenes[name_filter] # Hack to fix pybullet-pylab incompatibility on mac os if args.gui: import pylab as plt plt.figure() if args.debug: plt.ion() sim = Simulator(use_egl=False, gui=args.gui) # Change to no gui sim.cam.pos = [ 0., np.cos(np.deg2rad(args.angle)) * args.distance, np.sin(np.deg2rad(args.angle)) * args.distance ] sim.add_gripper(os.environ['GRIPPER_PATH']) net = Network(model_fn=args.network) _global_start = time.time() for scene_idx in range(len(scenes)): try: scene_name = scenes_ds['name'][scene_idx] logging.debug('Testing scene %s' % scene_name) sim.restore(scenes[scene_idx], os.environ['MODELS_PATH'])
def augment_label_maps(self, atlases: List[str], feature_list: List[str], label_list: List[str], single_feature_list: List[str], single_label_list: List[str]) -> None: if not atlases: return self.__services.debug.write( """Starting Augmentation: [ atlases: {}, feature_list: {}, label_list: {}, single_feature_list: {}, single_label_list: {} ] """.format(atlases, feature_list, label_list, single_feature_list, single_label_list), DebugLevel.BASIC) label_atlas_name = "training_" + "_".join(atlases) self.__services.debug.write("Loading maps", DebugLevel.BASIC) maps: List[Map] = [] for name in atlases: maps = maps + self.__services.resources.maps_dir.get_atlas( name).load_all() self.__services.debug.write("Loading atlas", DebugLevel.BASIC) t: List[Dict[str, any]] = self.__services.resources.training_data_dir.load( label_atlas_name) progress_bar: Progress = self.__services.debug.progress_debug( len(t), DebugLevel.BASIC) progress_bar.start() for i in range(len(t)): config = Configuration() config.simulator_algorithm_type = AStar config.simulator_testing_type = AStarTesting config.simulator_initial_map = maps[i] services: Services = Services(config) simulator: Simulator = Simulator(services) testing: AStarTesting = simulator.start() if feature_list: seq_features = MapProcessing.get_sequential_features( testing.map, feature_list) for q in range(len(t[i]["features"])): t[i]["features"][q].update(seq_features[q]) if label_list: seq_labels = MapProcessing.get_sequential_labels( testing.map, label_list) for q in range(len(t[i]["labels"])): t[i]["labels"][q].update(seq_labels[q]) if single_feature_list: t[i]["single_features"].update( MapProcessing.get_single_features(maps[i], single_feature_list)) if single_label_list: t[i]["single_labels"].update( MapProcessing.get_single_labels(maps[i], single_label_list)) progress_bar.step() self.__services.debug.write( "Saving atlas augmentation: " + str(label_atlas_name), DebugLevel.BASIC) self.__services.resources.training_data_dir.save(label_atlas_name, t) self.__services.debug.write( "Finished atlas augmentation: " + str(label_atlas_name) + "\n", DebugLevel.BASIC)
def __init__(self): self.simulator = Simulator()
class BinanceEnv(gym.Env): metadata = {'render.modes': ['human']} def __init__(self): super(BinanceEnv, self).__init__() self.action_space = spaces.Discrete(7) self.observation_space = spaces.Box(low=0, high=1, shape=(65,), dtype=np.float16) self.binance = BinanceReader() self.simulator = Simulator() self.current_step = 0 self.initial_step = 0 self.last_price = 0.0 self.is_testing = True def next_observation(self): # Get the stock data points for the last 5 days and scale to between 0-1 # asks, bids = self.simulator.get_order_book() # data = list() # for item in asks: # data.append(item[1]) # asks = np.asarray(data) # data = list() # for item in bids: # data.append(item[1]) # bids = np.asarray(data) recent_trades = self.simulator.get_recent_trades() # data = list() # for item in recent_trades: # data.append([item[1], item[2]]) # recent_trades = np.asarray(data) self.last_price = self.simulator.get_last_price() max_short, max_long = self.simulator.get_max_short_and_long() obs = np.append(recent_trades, self.simulator.profit) # obs = np.append(obs, recent_trades) # obs = np.append(obs, self.simulator.profit) obs = np.append(obs, self.simulator.balance) obs = np.append(obs, self.last_price) obs = np.append(obs, np.asarray(max_long)) obs = np.append(obs, np.asarray(max_short)) return np.asarray(obs, dtype=np.float) def reset(self): self.simulator = Simulator() if self.is_testing: self.current_step = 70000 else: self.current_step = random.randint(0, int(self.simulator.max_steps / 1.3)) self.simulator.current_step = self.current_step self.initial_step = self.current_step return self.next_observation() def _take_action(self, action_type): # Set the current price to a random price within the time step # print('\n action = ', action_type) if action_type == 0: volume = Decimal(abs(self.simulator.get_volume())) self.simulator.long(volume) elif action_type == 1: self.simulator.close_long(True) elif action_type == 2: self.simulator.close_long(False) elif action_type == 3: volume = Decimal(abs(self.simulator.get_volume())) self.simulator.short(volume) elif action_type == 4: self.simulator.close_short(True) elif action_type == 5: self.simulator.close_short(False) # self.render() def render(self, mode='human', close=False): # Render the environment to the screen self.simulator.update_account() print(f'Step: {self.current_step}') print(f'Current price: {self.last_price}') print(f'Balance: {self.simulator.balance}') print(f'Available balance: {self.simulator.available_balance}') print( f'Total trades:: {self.simulator.count_trades}') print( f'Current profit: {self.simulator.profit} (Max profit: {self.simulator.max_profit})') def step(self, action): # Execute one time step within the environment self._take_action(action) self.current_step += 1 self.simulator.current_step += 1 reward = float(self.simulator.reward) done = False if self.simulator.profit < - 100 \ or self.current_step + 1 == self.simulator.max_steps \ or self.current_step - self.initial_step > 10000: done = True obs = self.next_observation() return obs, reward, done, {}
def test_simulator_initialized_correct_size(): simulator = Simulator(31, 57) assert simulator.get_board_size() == [31, 57]
parser.add_argument('--nolog', action='store_true') parser.add_argument('--subsample', default=None, type=float, help='Subsample depth image by provided factor before feeding to network') parser.add_argument('--gui', action='store_true') parser.add_argument('-e', nargs='+', default=None, type=int, help='epochs to evaluate, if next arg is model, separate with -- ') args = parser.parse_args() model_fns = glob.glob(args.model + '/*.hdf5') assert len(model_fns) > 0 model_name = model_fns[0].split('/')[-2] # Get input size and initialize simulator camera with it from keras.models import load_model _, height, width, _ = load_model(model_fns[0]).input_shape sim = Simulator(gui=args.gui, timeout=4, debug=True, use_egl=False, stop_th=1e-3) sim.cam.height = height sim.cam.width = width scenes = h5py.File(args.scenes, 'r') dt = datetime.datetime.now().strftime('%y%m%d_%H%M') model_results_path = os.path.join(args.results, '{}_{}'.format(dt, model_name)) if not os.path.exists(model_results_path): os.makedirs(model_results_path) results_fn = model_results_path + '/results.txt' results_f = open(results_fn, 'w') results_f.write('ARGUMENTS:\n'+''.join(['{}: {}\n'.format(item[0], item[1]) for item in vars(args).items()])) results_f.write('---\n') print_attrs(scenes, results_f)
for name in PluginController().get_loaded_plugins(): result[name] = None return result parser = OptionParser() parser.add_option("-p", "--plugins", dest="plugins", help="List of plugins to load separated by commas") parser.add_option("-d", "--debug", default=False, action="store_true", dest="debug", help="Enable debug log") (options, args) = parser.parse_args() if options.debug: Logger.set_loglevel("DEBUGL2") sim = Simulator() sim.load_plugin("corecommands", "core") sim.load_plugin("aclcommands", "core") if options.plugins: plugins = options.plugins.split(",") for plugin in plugins: Logger.info("Loading %s" % plugin) try: sim.load_plugin(plugin) except Exception as e: Logger.log_traceback(sim) sys.exit(1)
def run_simulation(series=False): sim = Simulator("config/simulator_config.yaml", series=series) sim.train() return sim.config.General.rootdir
from simulator.workload_generator import WorkloadGenerator import copy if __name__ == '__main__': wGen = WorkloadGenerator(num_jobs=400, rate_jobs=5, rate_io=0.3, mean_job_time=800, mean_io_time=3, sd_job_time=5, sd_io_time=1, time_unit=1) ############################## # Simulate with Euler ############################## scheduler = RoundRobin(enableEuler=True) simulator = Simulator(scheduler) workload1 = wGen.generateWorkload() workload2 = copy.deepcopy(workload1) simulator.setWorkload(workload1) simulator.run() ############################## # Simulate without Euler ############################## scheduler = RoundRobin(enableEuler=False) simulator = Simulator(scheduler) simulator.setWorkload(workload2) simulator.run()
from simulator.simulator import Simulator from simulator.route_manager import RouteManager from algorithm import AlgorithmManager as algo # from algorithm import DummyAlgorithmManager as algo from connection import ConnectionManager as conn rm = RouteManager("simulator/maps/simple") #algo = AlgorithmManager sim = Simulator( rm, #route manager algo, #algorithm module conn, #connection module "simulator/maps/simple" #map folder ) rm.bind_simulator(sim) sim.start_simulation()
class LraClusterEnv(): def __init__(self, num_nodes): #: Cluster configuration self.NUM_NODES = num_nodes # node_id: 0,1,2,... #: fixed 9 apps self.NUM_APPS = 7 #: initialized state to zero matrix self._state_reset() # clustering self.baisc_oath_name = 'subScheduler_' path_surffix = "./checkpoint/" self.subScheduler_api_0 = subScheduler(path_name=self.baisc_oath_name + '0', surffix='0', path_surffix=path_surffix) self.subScheduler_api_1 = subScheduler(path_name=self.baisc_oath_name + '10', surffix='10', path_surffix=path_surffix) self.subScheduler_api_2 = subScheduler(path_name=self.baisc_oath_name + '20', surffix='20', path_surffix=path_surffix) self.subScheduler_api_3 = subScheduler(path_name=self.baisc_oath_name + '30', surffix='30', path_surffix=path_surffix) self.subScheduler_api_4 = subScheduler(path_name=self.baisc_oath_name + '40', surffix='40', path_surffix=path_surffix) self.subScheduler_api_5 = subScheduler(path_name=self.baisc_oath_name + '50', surffix='50', path_surffix=path_surffix) self.subScheduler_api_6 = subScheduler(path_name=self.baisc_oath_name + '60', surffix='60', path_surffix=path_surffix) self.subScheduler_api_7 = subScheduler(path_name=self.baisc_oath_name + '70', surffix='70', path_surffix=path_surffix) self.subScheduler_api_8 = subScheduler(path_name=self.baisc_oath_name + '80', surffix='80', path_surffix=path_surffix) self.subScheduler_api_9 = subScheduler(path_name=self.baisc_oath_name + '90', surffix='90', path_surffix=path_surffix) self.subScheduler_api_10 = subScheduler( path_name=self.baisc_oath_name + '100', surffix='100', path_surffix=path_surffix) self.subScheduler_api_11 = subScheduler( path_name=self.baisc_oath_name + '110', surffix='110', path_surffix=path_surffix) self.subScheduler_api_12 = subScheduler( path_name=self.baisc_oath_name + '120', surffix='120', path_surffix=path_surffix) self.subScheduler_api_13 = subScheduler( path_name=self.baisc_oath_name + '130', surffix='130', path_surffix=path_surffix) self.subScheduler_api_14 = subScheduler( path_name=self.baisc_oath_name + '140', surffix='140', path_surffix=path_surffix) self.subScheduler_api_15 = subScheduler( path_name=self.baisc_oath_name + '150', surffix='150', path_surffix=path_surffix) self.subScheduler_api_16 = subScheduler( path_name=self.baisc_oath_name + '160', surffix='160', path_surffix=path_surffix) self.subScheduler_api_17 = subScheduler( path_name=self.baisc_oath_name + '170', surffix='170', path_surffix=path_surffix) self.subScheduler_api_18 = subScheduler( path_name=self.baisc_oath_name + '180', surffix='180', path_surffix=path_surffix) self.subScheduler_api_19 = subScheduler( path_name=self.baisc_oath_name + '190', surffix='190', path_surffix=path_surffix) self.sim = Simulator() def _state_reset(self): self.state = np.zeros([self.NUM_NODES, self.NUM_APPS]) def reset(self): self._state_reset() return self._get_state() def step(self, action, appid): """ :param action: node chosen :param appid: current app_id of the container to be allocated :return: new state after allocation """ curr_app = appid self.state[action][curr_app] += 1 # locate state = self._get_state() return state def _get_state(self): return self.state @property def _get_throughput(self): state_all = np.empty([0, self.NUM_APPS]) for nid in range(self.NUM_NODES): container_list = self.state[nid] num_container = sum(container_list) predictor_class = int((num_container - 1) / 10) if predictor_class > 19: predictor_class = 19 assert (predictor_class >= 0) & (predictor_class <= 19) if predictor_class == 0: state_this = self.subScheduler_api_0.get_total_tput( container_list) elif predictor_class == 1: state_this = self.subScheduler_api_1.get_total_tput( container_list) elif predictor_class == 2: state_this = self.subScheduler_api_2.get_total_tput( container_list) elif predictor_class == 3: state_this = self.subScheduler_api_3.get_total_tput( container_list) elif predictor_class == 4: state_this = self.subScheduler_api_4.get_total_tput( container_list) elif predictor_class == 5: state_this = self.subScheduler_api_5.get_total_tput( container_list) elif predictor_class == 6: state_this = self.subScheduler_api_6.get_total_tput( container_list) elif predictor_class == 7: state_this = self.subScheduler_api_7.get_total_tput( container_list) elif predictor_class == 8: state_this = self.subScheduler_api_8.get_total_tput( container_list) elif predictor_class == 9: state_this = self.subScheduler_api_9.get_total_tput( container_list) elif predictor_class == 10: state_this = self.subScheduler_api_10.get_total_tput( container_list) elif predictor_class == 11: state_this = self.subScheduler_api_11.get_total_tput( container_list) elif predictor_class == 12: state_this = self.subScheduler_api_12.get_total_tput( container_list) elif predictor_class == 13: state_this = self.subScheduler_api_13.get_total_tput( container_list) elif predictor_class == 14: state_this = self.subScheduler_api_14.get_total_tput( container_list) elif predictor_class == 15: state_this = self.subScheduler_api_15.get_total_tput( container_list) elif predictor_class == 16: state_this = self.subScheduler_api_16.get_total_tput( container_list) elif predictor_class == 17: state_this = self.subScheduler_api_17.get_total_tput( container_list) elif predictor_class == 18: state_this = self.subScheduler_api_18.get_total_tput( container_list) elif predictor_class == 19: state_this = self.subScheduler_api_19.get_total_tput( container_list) state_all = np.append(state_all, state_this, 0) total_tput = (self.sim.predict(state_all.reshape(-1, self.NUM_APPS)) * state_all).sum() return total_tput def get_tput_total_env(self): return self._get_throughput
# if real1 or real2: # world = common.world.World(colour) # else: world = simulator.world.World(colour) assert not (real1 and real2), \ "How are we to run 2 physical robots??" pitch = selectPitch(inputs, once) sim = Simulator( pitch=pitch, vision=vision, headless=headless, world=world, robot1=(ai1, real1), robot2=(ai2, real2), colour=colour, real_world=None, #(real1 or real2), ) sim.run() def selectPitch(inputs, once): selectedInputs = [ k for k,v in inputs.items() if v ] if len(selectedInputs) > 1: print "Only one pitch input can be used at a time" sys.exit(2) elif len(selectedInputs) == 0: # The default is to use a static background name = 'image' inputs['image'] = "vision/media/calibrated-background-cropped.png"
noise_type=noise_type, batch_size=batch_size, proba_coeff=proba_coeff, train_data_size=train_data_size, version='v5') names.append(name) scheduled_lr = {1: 0.1, 62000: 0.01} # annealing of learning rate sim = Simulator(model=model, learning_rate=learning_rate, noise_list=noise_list, batch_size=batch_size, n_epochs=n_epochs, name=name, burn_in_period=burn_in_period, noise_type=noise_type, scheduled_lr=scheduled_lr, swap_step=swap_step, separation_ratio=0, n_simulations=1, test_step=test_step, loss_func_name=loss_func_name, proba_coeff=proba_coeff, mode=None) sim.train(train_data_size=train_data_size, train_data=x_train, train_labels=y_train, validation_data=x_valid, validation_labels=y_valid, test_data=x_test, test_labels=y_test)
def actor(self): simulator = Simulator(scenario=self.scenarios[0]) return simulator.combatant_by_name(self.actor_name)
for trial in range(0, repeat_count): # Set one manually... #seed = "\x61\xcb\x82\x90" seed = os.urandom(4) print "random.seed() = 0x{}".format(binascii.hexlify(seed)) random.seed(seed) # Set message printing level Simulator.EXTRA_VERBOSE = False Simulator.VERBOSE = False Channel.VERBOSE = False Node.EXTRA_VERBOSE = False Node.EXTRA_VERBOSE = False sim = Simulator() loss_rate = 0.60 # loss rate (0.0 to 1.0) min_delay = 0.000001 # 1 micro-second minimum delay mean_dealy = 0.000020 # 20 micro-second delay delay_generator = ExponentialDelay(min_delay, mean_dealy) alice_output = Channel(sim, delay_generator, loss_rate) alice = Node(sim, "ALICE", True, alice_output) bob_output = Channel(sim, delay_generator, loss_rate) bob = Node(sim, "BOB ", False, bob_output) alice.set_peer(bob) bob.set_peer(alice)
def test_step(self): road = Mock() dispatcher = Mock() simulator = Simulator(road=road, dispatcher=dispatcher) # No hooks. simulator.step() self.assertEqual(simulator.steps, 1) dispatcher.dispatch.assert_called_once() road.step.assert_called_once() # Test hooks are run. hook = Mock() simulator.addHook(hook) simulator.step() self.assertEqual(simulator.steps, 2) hook.run.assert_called_once() # Tests hooks are removed correctly. hook.run.reset_mock() simulator.removeHook(hook) simulator.step() self.assertEqual(simulator.steps, 3) hook.run.assert_not_called()
import signal import sys from simulator.car import Car from simulator.recorder import Recorder from simulator.simulator import Simulator def signal_handler(signal, frame): recorder.stop() print 'Recording Saved to ' + recorder.file_name sys.exit(0) simulator = Simulator() car = Car(simulator) recorder = Recorder(car) simulator.connect() simulator.start() recorder.start() print 'Now Recording Driving...' print 'Press Ctrl-C to Stop Recording' signal.signal(signal.SIGINT, signal_handler) signal.pause()
import sys import os sys.path.insert(1, os.path.join(sys.path[0], '..')) from simulator.action_history import ActionHistory from simulator.plotter import Plotter from simulator.simulator import Simulator from graph_known_correspondence import GraphSLAM import numpy as np if __name__ == '__main__': dt = 1.0 # load testcase s = Simulator('../testcase/map2.txt', '../testcase/robot1.txt') ah = ActionHistory(dt) ah.LoadFromFile('../testcase/action_history_loop.txt') # set up the SLAM algorithm Q = np.diag([0.1, 0.1, 0.1]) # process noise; (x, y, theta). should be over-estimates R = np.diag([0.2, 0.2, 0.01]) # measurement noise; (dist, bearing, signature), algo = GraphSLAM() algo.Initialize(Q, R, ah.GetLength(), s.world.GetFeatureCount()) # test the SLAM algorithm with the simulator ah.Rewind() while (not ah.EOF()): t, ra = ah.GetNext() m = s.Update(t, ra) algo.Update(t, ra, m)
import random from time import time import matplotlib.pyplot as plt import numpy as np from simulator.simulator import Simulator from mcl_algorithms.trinary_mcl.main import TrinaryMCL if __name__ == "__main__": start = time() simulator = Simulator() num_time_instances = 100 percentage_are_anchors = 0.2 num_nodes = 50 communication_radius = 50 max_width = 500 max_height = 500 max_v = 10 # random.seed(0) simulator_results, algorithm_results = simulator.run( num_time_instances=num_time_instances, num_nodes=num_nodes, num_anchors=num_nodes * percentage_are_anchors, stage_size=(max_width, max_height), max_v=max_v, communication_radius=communication_radius)
from simulator.simulator import Simulator simulator = Simulator(1) simulator.initSimulation(10)