def init_url_user_auth_data(self): user_ids = [] users = read_json_file(self._user_file_path())['users'] for user in users: roles = [] for role in user['roles']: auth_objects = [] for auth in role['authorizations']: # 创建授权和资源 url = URLOperation(**auth['resource']) url.save() auth_obj, created = Authorization.objects.get_or_create( name=auth['name'], resource_id=url.pk, type=auth['type']) auth_objects.append(auth_obj) role_obj, created = Role.objects.get_or_create( name=role['name']) for auth in auth_objects: role_obj.authorizations.add(auth) roles.append(role_obj) password = make_password(user['password'], user['salt']) user_obj = User(name=user['name'], password=password, salt=user['salt']) user_obj.save() for role in roles: user_obj.roles.add(role) user_ids.append(user_obj.pk) return user_ids
def to_csv(config_file): bo_log = read_json_file(config_file) csv_file = os.path.join( os.path.dirname(config_file), os.path.splitext(os.path.basename(config_file))[0] + ".csv") with open(csv_file, 'w') as f: writer = csv.writer(f, lineterminator='\n') header = ['bandwidth_lower_bound_min', 'bandwidth_lower_bound_max', 'bandwidth_upper_bound_min', 'bandwidth_upper_bound_max', 'delay_min', 'delay_max', 'queue_min', 'queue_max', 'loss_min', 'loss_max', 'T_s_min', 'T_s_max', 'delay_noise_min', 'delay_noise_max', 'duration_min', 'duration_max', 'weight'] writer.writerow(header) for config in bo_log: writer.writerow([ config['bandwidth_lower_bound'][0], config['bandwidth_lower_bound'][1], config['bandwidth_upper_bound'][0], config['bandwidth_upper_bound'][1], config['delay'][0], config['delay'][1], config['queue'][0], config['queue'][1], config['loss'][0], config['loss'][1], config['T_s'][0], config['T_s'][1], config['delay_noise'][0], config['delay_noise'][1], config['duration'][0], config['duration'][1], config['weight']])
def __init__(self, trace_file, calibrate_timestamps=False, use_cache=True, start_time=None, end_time=None): self.use_cache = use_cache trace_file_basename = os.path.basename(trace_file) trace_file_dirname = os.path.dirname(trace_file) cc = extract_cc_name(trace_file) summary_path = os.path.join(str(trace_file_dirname), '{}_conn_summary.json'.format(cc)) self.cache = {} if not self.use_cache or (self.use_cache and not os.path.exists(summary_path)): self.datalink = Flow(trace_file, start_time=start_time, end_time=end_time) self.acklink = Flow(os.path.join( str(trace_file_dirname), str(trace_file_basename.replace("datalink", "acklink"))), start_time=start_time, end_time=end_time) if calibrate_timestamps: self.t_offset = min(self.datalink.throughput_timestamps[0], self.datalink.sending_rate_timestamps[0]) else: self.t_offset = 0 self.cache['cc'] = self.cc self.cache[ 'link_capacity_timestamps'] = self.link_capacity_timestamps self.cache['link_capacity'] = self.link_capacity self.cache['avg_link_capacity'] = self.avg_link_capacity self.cache['throughput_timestamps'] = self.throughput_timestamps self.cache['throughput'] = self.throughput self.cache['avg_throughput'] = self.avg_throughput self.cache[ 'sending_rate_timestamps'] = self.sending_rate_timestamps self.cache['sending_rate'] = self.sending_rate self.cache['avg_sending_rate'] = self.avg_sending_rate self.cache[ 'datalink_delay_timestamps'] = self.datalink_delay_timestamps self.cache['datalink_delay'] = self.datalink_delay self.cache[ 'acklink_delay_timestamps'] = self.acklink_delay_timestamps self.cache['acklink_delay'] = self.acklink_delay self.cache['loss_rate'] = self.datalink.loss_rate self.cache['min_one_way_delay'] = self.min_one_way_delay self.cache['min_rtt'] = self.min_rtt self.cache['rtt_timestamps'] = self.rtt_timestamps self.cache['rtt'] = self.rtt self.cache['avg_rtt'] = self.avg_rtt self.cache['percentile_rtt'] = self.percentile_rtt write_json_file(summary_path, self.cache) else: self.cache = read_json_file(summary_path)
def load_from_file(filename: str): trace_data = read_json_file(filename) tr = Trace(trace_data['timestamps'], trace_data['bandwidths'], trace_data['delays'], trace_data['loss'], trace_data['queue'], delay_noise=trace_data['delay_noise'] if 'delay_noise' in trace_data else 0) return tr
def __init__(self, filename: str) -> None: self.filename = filename if filename and os.path.exists(filename): self.rand_ranges = read_json_file(filename) assert isinstance(self.rand_ranges, List) and len( self.rand_ranges) >= 1, "rand_ranges object should be a list with length at least 1." weight_sum = 0 for rand_range in self.rand_ranges: weight_sum += rand_range['weight'] assert weight_sum == 1.0, "Weight sum should be 1." self.parameters = set(self.rand_ranges[0].keys()) self.parameters.remove('weight') else: self.rand_ranges = [] self.parameters = set()
def reset(self): self.steps_taken = 0 self.net.reset() # old snippet start # self.current_trace = np.random.choice(self.traces) # old snippet end # choose real trace with a probability. otherwise, use synthetic trace if self.train_flag and self.config_file: self.current_trace = generate_traces(self.config_file, 1, duration=30)[0] if random.uniform(0, 1) < self.real_trace_prob and self.traces: cur_config = read_json_file(self.config_file)[0] cur_config['weight'] = 1 self.current_trace = generate_trace_from_config([cur_config]) import pdb pdb.set_trace() else: self.current_trace = np.random.choice(self.traces) # if self.train_flag and not self.config_file: # bdp = np.max(self.current_trace.bandwidths) / BYTES_PER_PACKET / \ # BITS_PER_BYTE * 1e6 * np.max(self.current_trace.delays) * 2 / 1000 # self.current_trace.queue_size = max(2, int(bdp * np.random.uniform(0.2, 3.0))) # hard code this for now # loss_rate_exponent = float(np.random.uniform(np.log10(0+1e-5), np.log10(0.5+1e-5), 1)) # if loss_rate_exponent < -4: # loss_rate = 0 # else: # loss_rate = 10**loss_rate_exponent # self.current_trace.loss_rate = loss_rate self.current_trace.reset() self.create_new_links_and_senders() self.net = Network(self.senders, self.links, self) self.episodes_run += 1 # old code snippet start # if self.train_flag and self.config_file is not None and self.episodes_run % 100 == 0: # self.traces = generate_traces(self.config_file, 10, duration=30) # old code snippet end self.net.run_for_dur(self.run_dur) self.reward_ewma *= 0.99 self.reward_ewma += 0.01 * self.reward_sum self.reward_sum = 0.0 return self._get_all_sender_obs()
def generate_configs(config_file: str, n: int): config_range = read_json_file(config_file)[0] configs = [] for _ in range(n): min_bw = 10**np.random.uniform( np.log10(config_range['bandwidth_lower_bound'][0]), np.log10(config_range['bandwidth_lower_bound'][1]), 1)[0] max_bw = 10**np.random.uniform( np.log10(config_range['bandwidth_upper_bound'][0]), np.log10(config_range['bandwidth_upper_bound'][1]), 1)[0] delay = np.random.uniform(config_range['delay'][0], config_range['delay'][1], 1)[0] queue = np.random.uniform(config_range['queue'][0], config_range['queue'][1], 1)[0] T_s = np.random.uniform(config_range['T_s'][0], config_range['T_s'][1], 1)[0] loss_exponent = np.random.uniform( np.log10(config_range['loss'][0] + 1e-5), np.log10(config_range['loss'][1] + 1e-5), 1)[0] loss = 0 if loss_exponent < -4 else 10**loss_exponent configs.append([min_bw, max_bw, delay, queue, loss, T_s]) return configs
def main(): bbr = BBR(True) cubic = Cubic(True) # cubic = Cubic(20) genet = Aurora(seed=20, log_dir=RESULT_ROOT, pretrained_model_path=GENET_MODEL_PATH, timesteps_per_actorbatch=10, delta_scale=1) udr_small = Aurora(seed=20, log_dir=RESULT_ROOT, pretrained_model_path=UDR_SMALL_MODEL_PATH, timesteps_per_actorbatch=10, delta_scale=1) udr_mid = Aurora(seed=20, log_dir=RESULT_ROOT, pretrained_model_path=UDR_MID_MODEL_PATH, timesteps_per_actorbatch=10, delta_scale=1) udr_large = Aurora(seed=20, log_dir=RESULT_ROOT, pretrained_model_path=UDR_LARGE_MODEL_PATH, timesteps_per_actorbatch=10, delta_scale=1) # for _ in range(10): # DEFAULT_CONFIGS.append( # { # "bandwidth": 10 ** np.random.uniform(np.log10(1), np.log10(10), 1).item(), # "delay": np.random.uniform(5, 200, 1).item(), # "loss": np.random.uniform(0, 0.0, 1).item(), # "queue": 10 ** np.random.uniform(np.log10(2), np.log10(30), 1).item(), # "T_s": np.random.randint(0, 6, 1).item(), # "delay_noise": np.random.uniform(0, 0, 1).item()}) # print(DEFAULT_CONFIGS) udr_train_config = read_json_file(UDR_TRAIN_CONFIG_FILE)[0] # print(udr_train_config) for dim, unit in zip(DIMS_TO_VARY, DIM_UNITS): print(dim, udr_train_config[dim]) if dim == 'bandwidth': vals_to_test = 10**np.linspace( np.log10(1), np.log10(udr_train_config[dim][1]), 10) elif dim == 'queue': vals_to_test = 10**np.linspace( np.log10(udr_train_config[dim][0]), np.log10(udr_train_config[dim][1]), 10) elif dim == 'loss': vals_to_test = np.linspace(0, 0.005, 10) else: vals_to_test = np.linspace( udr_train_config[dim][0], udr_train_config[dim][1], 10) print(vals_to_test) bbr_avg_rewards = [] bbr_reward_errs = [] cubic_avg_rewards = [] cubic_reward_errs = [] udr_small_avg_rewards = [] udr_small_reward_errs = [] udr_mid_avg_rewards = [] udr_mid_reward_errs = [] udr_large_avg_rewards = [] udr_large_reward_errs = [] genet_avg_rewards = [] genet_reward_errs = [] for val_idx, val in enumerate(vals_to_test): if dim == 'bandwidth': max_bw = val else: max_bw = DEFAULT_VALUES['bandwidth'] if dim == 'delay': min_delay, max_delay = val, val else: min_delay, max_delay = DEFAULT_VALUES['delay'], DEFAULT_VALUES['delay'] if dim == 'loss': min_loss, max_loss = val, val else: min_loss, max_loss = DEFAULT_VALUES['loss'], DEFAULT_VALUES['loss'] if dim == 'queue': min_queue, max_queue = val, val else: min_queue, max_queue = DEFAULT_VALUES['queue'], DEFAULT_VALUES['queue'] if dim == 'T_s': min_T_s, max_T_s = val, val else: min_T_s, max_T_s = DEFAULT_VALUES['T_s'], DEFAULT_VALUES['T_s'] # generate n=10 traces for each config traces = [generate_trace(duration_range=(30, 30), bandwidth_range=(1, max_bw), delay_range=(min_delay, max_delay), loss_rate_range=(min_loss, max_loss), queue_size_range=(min_queue, max_queue), T_s_range=(min_T_s, max_T_s), delay_noise_range=(0, 0), constant_bw=False, seed=i) for i in range(10)] bbr_rewards = [] cubic_rewards = [] udr_small_rewards = [] udr_mid_rewards = [] udr_large_rewards = [] genet_rewards = [] for i, trace in enumerate(tqdm(traces)): save_dir = os.path.join(RESULT_ROOT, EXP_NAME, "vary_{}".format( dim), "val_{}".format(val_idx), "trace_{}".format(i)) os.makedirs(save_dir, exist_ok=True) trace_file = os.path.join(save_dir, "trace_{}.json".format(i)) trace.dump(trace_file) # bbr # save_dir = os.path.join(RESULT_ROOT, EXP_NAME, "vary_{}".format( # dim), "val_{}".format(val_idx), "trace_{}".format(i), "bbr") # os.makedirs(save_dir, exist_ok=True) # # if os.path.exists(os.path.join(save_dir, "bbr_packet_log.csv")): # pkt_log = PacketLog.from_log_file( # os.path.join(save_dir, "bbr_packet_log.csv")) # pkt_level_reward = pkt_log.get_reward("", trace) # else: # test_reward, pkt_level_reward = bbr.test(trace, save_dir) # # # bbr_rewards.append(test_reward) # bbr_rewards.append(pkt_level_reward) # cubic # save_dir = os.path.join(RESULT_ROOT, EXP_NAME, "vary_{}".format( # dim), "val_{}".format(val_idx), "trace_{}".format(i), "cubic") # os.makedirs(save_dir, exist_ok=True) # # if os.path.exists(os.path.join(save_dir, "cubic_packet_log.csv")): # pkt_log = PacketLog.from_log_file( # os.path.join(save_dir, "cubic_packet_log.csv")) # pkt_level_reward = pkt_log.get_reward("", trace) # else: # test_reward, pkt_level_reward = cubic.test(trace, save_dir) # # cubic_rewards.append(test_reward) # cubic_rewards.append(pkt_level_reward) # cmd = "python ../plot_scripts/plot_packet_log.py --log-file {} " \ # "--save-dir {} --trace-file {}".format( # os.path.join(save_dir, "cubic_packet_log.csv"), # save_dir, trace_file) # subprocess.check_output(cmd, shell=True).strip() # cmd = "python ../plot_scripts/plot_time_series.py --log-file {} " \ # "--save-dir {} --trace-file {}".format( # os.path.join(save_dir, "cubic_simulation_log.csv"), # save_dir, trace_file) # subprocess.check_output(cmd, shell=True).strip() # genet save_dir = os.path.join(RESULT_ROOT, EXP_NAME, "vary_{}".format( dim), "val_{}".format(val_idx), "trace_{}".format(i), "genet") if os.path.exists(os.path.join(save_dir, "aurora_packet_log.csv")): pkt_log = PacketLog.from_log_file( os.path.join(save_dir, "aurora_packet_log.csv")) else: _, reward_list, _, _, _, _, _, _, _, pkt_log = genet.test( trace, save_dir) pkt_log = PacketLog.from_log(pkt_log) genet_rewards.append(pkt_log.get_reward("", trace)) # udr_small # save_dir = os.path.join(RESULT_ROOT, EXP_NAME, "vary_{}".format( # dim), "val_{}".format(val_idx), "trace_{}".format(i), "udr_small") # if os.path.exists(os.path.join(save_dir, "aurora_packet_log.csv")): # pkt_log = PacketLog.from_log_file( # os.path.join(save_dir, "aurora_packet_log.csv")) # else: # _, reward_list, _, _, _, _, _, _, _, pkt_log = udr_small.test( # trace, save_dir) # pkt_log = PacketLog.from_log(pkt_log) # udr_small_rewards.append(pkt_log.get_reward("", trace)) # # # udr_mid # save_dir = os.path.join(RESULT_ROOT, EXP_NAME, "vary_{}".format( # dim), "val_{}".format(val_idx), "trace_{}".format(i), "udr_mid") # if os.path.exists(os.path.join(save_dir, "aurora_packet_log.csv")): # pkt_log = PacketLog.from_log_file( # os.path.join(save_dir, "aurora_packet_log.csv")) # else: # _, reward_list, _, _, _, _, _, _, _, pkt_log = udr_mid.test( # trace, save_dir) # pkt_log = PacketLog.from_log(pkt_log) # udr_mid_rewards.append(pkt_log.get_reward("", trace)) # _, reward_list, _, _, _, _, _, _, _, pkt_log = udr_mid.test( # trace, save_dir) # # test_reward = np.mean(reward_list) # # udr_mid_rewards.append(test_reward) # # # udr_large # save_dir = os.path.join(RESULT_ROOT, EXP_NAME, "vary_{}".format( # dim), "val_{}".format(val_idx), "trace_{}".format(i), "udr_large") # os.makedirs(save_dir, exist_ok=True) # if os.path.exists(os.path.join(save_dir, "aurora_packet_log.csv")): # pkt_log = PacketLog.from_log_file( # os.path.join(save_dir, "aurora_packet_log.csv")) # else: # _, reward_list, _, _, _, _, _, _, _, pkt_log = udr_large.test( # trace, save_dir) # pkt_log = PacketLog.from_log(pkt_log) # # test_reward = np.mean(reward_list) # # udr_large_rewards.append(test_reward) # udr_large_rewards.append(pkt_log.get_reward("", trace)) # # cmd = "python ../plot_scripts/plot_packet_log.py --log-file {} " \ # # "--save-dir {} --trace-file {}".format( # # os.path.join(save_dir, "aurora_packet_log.csv"), # # save_dir, trace_file) # # subprocess.check_output(cmd, shell=True).strip() # # cmd = "python ../plot_scripts/plot_time_series.py --log-file {} " \ # # "--save-dir {} --trace-file {}".format( # # os.path.join(save_dir, "aurora_simulation_log.csv"), # # save_dir, trace_file) # # subprocess.check_output(cmd, shell=True).strip() # # # # genet_model.test(trace) print(len(cubic_avg_rewards), len(udr_large_avg_rewards)) bbr_avg_rewards.append(np.mean(bbr_rewards)) bbr_reward_errs.append( np.std(bbr_rewards) / np.sqrt(len(bbr_rewards))) cubic_avg_rewards.append(np.mean(cubic_rewards)) cubic_reward_errs.append( np.std(cubic_rewards) / np.sqrt(len(cubic_rewards))) udr_small_avg_rewards.append(np.mean(udr_small_rewards)) udr_small_reward_errs.append( np.std(udr_small_rewards) / np.sqrt(len(udr_small_rewards))) udr_mid_avg_rewards.append(np.mean(udr_mid_rewards)) udr_mid_reward_errs.append( np.std(udr_mid_rewards) / np.sqrt(len(udr_mid_rewards))) udr_large_avg_rewards.append(np.mean(udr_large_rewards)) udr_large_reward_errs.append( np.std(udr_large_rewards) / np.sqrt(len(udr_large_rewards))) genet_avg_rewards.append(np.mean(genet_rewards)) genet_reward_errs.append( np.std(genet_rewards) / np.sqrt(len(genet_rewards))) plt.figure() ax = plt.gca() import pdb pdb.set_trace() ax.plot(vals_to_test, genet_avg_rewards, color='C2', linewidth=4, alpha=1, linestyle='-', label="GENET") genet_low_bnd = np.array(genet_avg_rewards) - \ np.array(genet_reward_errs) genet_up_bnd = np.array(genet_avg_rewards) + \ np.array(genet_reward_errs) ax.fill_between(vals_to_test, genet_low_bnd, genet_up_bnd, color='C2', alpha=0.1) ax.plot(vals_to_test, bbr_avg_rewards, color='C0', linestyle='-.', linewidth=4, alpha=1, label="BBR") bbr_low_bnd = np.array(bbr_avg_rewards) - \ np.array(bbr_reward_errs) bbr_up_bnd = np.array(bbr_avg_rewards) + \ np.array(bbr_reward_errs) ax.fill_between(vals_to_test, bbr_low_bnd, bbr_up_bnd, color='C0', alpha=0.1) ax.plot(vals_to_test, cubic_avg_rewards, color='C0', linestyle='-', linewidth=4, alpha=1, label="TCP Cubic") cubic_low_bnd = np.array(cubic_avg_rewards) - \ np.array(cubic_reward_errs) cubic_up_bnd = np.array(cubic_avg_rewards) + \ np.array(cubic_reward_errs) ax.fill_between(vals_to_test, cubic_low_bnd, cubic_up_bnd, color='C0', alpha=0.1) ax.plot(vals_to_test, udr_small_avg_rewards, color='grey', linewidth=4, linestyle=':', label="UDR-1") udr_small_low_bnd = np.array( udr_small_avg_rewards) - np.array(udr_small_reward_errs) udr_small_up_bnd = np.array( udr_small_avg_rewards) + np.array(udr_small_reward_errs) ax.fill_between(vals_to_test, udr_small_low_bnd, udr_small_up_bnd, color='grey', alpha=0.1) ax.plot(vals_to_test, udr_mid_avg_rewards, color='grey', linewidth=4, linestyle='--', label="UDR-2") udr_mid_low_bnd = np.array( udr_mid_avg_rewards) - np.array(udr_mid_reward_errs) udr_mid_up_bnd = np.array(udr_mid_avg_rewards) + \ np.array(udr_mid_reward_errs) ax.fill_between(vals_to_test, udr_mid_low_bnd, udr_mid_up_bnd, color='grey', alpha=0.1) ax.plot(vals_to_test, udr_large_avg_rewards, color='grey', linewidth=4, linestyle='-.', label="UDR-3") udr_large_low_bnd = np.array( udr_large_avg_rewards) - np.array(udr_large_reward_errs) udr_large_up_bnd = np.array( udr_large_avg_rewards) + np.array(udr_large_reward_errs) ax.fill_between(vals_to_test, udr_large_low_bnd, udr_large_up_bnd, color='grey', alpha=0.1) ax.set_xlabel("{}({})".format(dim, unit)) ax.set_ylabel("Reward") ax.legend() plt.tight_layout() with open(os.path.join(RESULT_ROOT, EXP_NAME, "sim_eval_vary_{}_bbr_with_cubic.csv".format(dim)), 'w') as f: writer = csv.writer(f) writer.writerow([dim, 'genet_avg_rewards', 'genet_low_bnd', 'genet_up_bnd', 'bbr_avg_rewards', 'bbr_low_bnd', 'bbr_up_bnd', 'cubic_avg_rewards', 'cubic_low_bnd', 'cubic_up_bnd', 'udr_small_avg_rewards', 'udr_small_low_bnd', 'udr_small_up_bnd', 'udr_mid_avg_rewards', 'udr_mid_low_bnd', 'udr_mid_up_bnd', 'udr_large_avg_rewards', 'udr_large_low_bnd', 'udr_large_up_bnd']) writer.writerows(zip(vals_to_test, genet_avg_rewards, genet_low_bnd, genet_up_bnd, bbr_avg_rewards, bbr_low_bnd, bbr_up_bnd, cubic_avg_rewards, cubic_low_bnd, cubic_up_bnd, udr_small_avg_rewards, udr_small_low_bnd, udr_small_up_bnd, udr_mid_avg_rewards, udr_mid_low_bnd, udr_mid_up_bnd, udr_large_avg_rewards, udr_large_low_bnd, udr_large_up_bnd)) save_dir = os.path.join(RESULT_ROOT, EXP_NAME, "sim_eval_vary_{}_bbr_with_cubic.png".format(dim)) save_dir = os.path.join(RESULT_ROOT, EXP_NAME, "sim_eval_vary_{}_bbr_with_cubic.pdf".format(dim)) plt.savefig(save_dir)
def main(): args = parse_args() set_seed(args.seed) # tokens = os.path.basename(os.path.dirname(os.path.dirname(args.save_dir))).split('_') # config0_dim0_idx = int(tokens[1]) # config0_dim1_idx = int(tokens[2]) # config1_dim0_idx = int(tokens[4]) # config1_dim1_idx = int(tokens[5]) dim0, dim1 = args.dims config = read_json_file(args.config_file)[0] assert dim0 in config and dim1 in config # dim0_vals = np.linspace(config[dim0][0], config[dim0][1], 10) # dim1_vals = np.linspace(config[dim1][0], config[dim1][1], 10) dim0_vals = get_dim_vals(dim0) dim1_vals = get_dim_vals(dim1) print(dim0_vals) print(dim1_vals) traces = [] save_dirs = [] with open('heatmap_trace_cnt_ratio.npy', 'rb') as f: cnt_ratio = np.load(f) for dim0_idx, dim0_val in enumerate(dim0_vals): for dim1_idx, dim1_val in enumerate(dim1_vals): dim_vals = copy.copy(DEFAULT_VALUES) dim_vals[dim0] = dim0_val dim_vals[dim1] = dim1_val # print(i, dim0_val, dim1_val, dim_vals) cnt = 10 # if cnt_ratio[dim0_idx, dim1_idx] > 1: # cnt *= int(cnt_ratio[dim0_idx, dim1_idx]) # print(cnt) for trace_idx in range(cnt): trace = generate_trace( duration_range=(dim_vals['duration'], dim_vals['duration']), bandwidth_lower_bound_range=( dim_vals['bandwidth_lower_bound'], dim_vals['bandwidth_lower_bound']), bandwidth_upper_bound_range=( dim_vals['bandwidth_upper_bound'], dim_vals['bandwidth_upper_bound']), delay_range=(dim_vals['delay'], dim_vals['delay']), loss_rate_range=(dim_vals['loss'], dim_vals['loss']), queue_size_range=(dim_vals['queue'], dim_vals['queue']), T_s_range=(dim_vals['T_s'], dim_vals['T_s']), delay_noise_range=(dim_vals['delay_noise'], dim_vals['delay_noise'])) traces.append(trace) save_dir = os.path.join( args.save_dir, 'pair_{}_{}'.format(dim0_idx, dim1_idx), 'trace_{}'.format(trace_idx)) save_dirs.append(save_dir) os.makedirs(save_dir, exist_ok=True) trace.dump( os.path.join(save_dir, 'trace_{}.json'.format(trace_idx))) if args.cc == 'genet_bbr' or args.cc == 'genet_cubic' or args.cc == 'genet_bbr_old': genet_seed = '' for s in args.models_path.split('/'): if 'seed' in s: genet_seed = s for bo in range(0, 30, 3): # for bo_dir in natural_sort(glob.glob(os.path.join(args.models_path, "bo_*/"))): bo_dir = os.path.join(args.models_path, "bo_{}".format(bo)) step = 64800 model_path = os.path.join(bo_dir, 'model_step_{}.ckpt'.format(step)) if not os.path.exists(model_path + '.meta'): print(model_path, 'does not exist') continue print(model_path) genet_save_dirs = [ os.path.join(save_dir, args.cc, genet_seed, "bo_{}".format(bo), "step_{}".format(step)) for save_dir in save_dirs ] t_start = time.time() test_on_traces(model_path, traces, genet_save_dirs, args.nproc, 42, False, False) print('bo {}: {:.3f}'.format(bo, time.time() - t_start)) elif args.cc == 'pretrained': pretrained_save_dirs = [ os.path.join(save_dir, args.cc) for save_dir in save_dirs ] t_start = time.time() test_on_traces(args.models_path, traces, pretrained_save_dirs, args.nproc, 42, False, False) print('pretrained: {:.3f}'.format(time.time() - t_start)) elif args.cc == 'overfit_config': overfit_config_save_dirs = [ os.path.join(save_dir, args.cc) for save_dir in save_dirs ] t_start = time.time() test_on_traces(args.models_path, traces, overfit_config_save_dirs, args.nproc, 42, False, False) print('overfit_config: {:.3f}'.format(time.time() - t_start)) else: if args.cc == 'bbr': cc = BBR(False) elif args.cc == 'cubic': cc = Cubic(False) elif args.cc == 'bbr_old': cc = BBR_old(False) else: raise NotImplementedError heuristic_save_dirs = [ os.path.join(save_dir, cc.cc_name) for save_dir in save_dirs ] t_start = time.time() cc.test_on_traces(traces, heuristic_save_dirs, False, args.nproc) print('{}: {:.3f}'.format(args.cc, time.time() - t_start))
def load_from_file(filename: str): trace_data = read_json_file(filename) tr = AbrTrace(trace_data['timestamps'], trace_data['bandwidths'], trace_data['link_rtt'], trace_data['buffer_thresh'], trace_data['name']) return tr
def generate_trace_from_config_file(config_file: str): config = read_json_file(config_file) return generate_trace_from_config(config)
def generate_trace_from_config_file(config_file: str, duration: int = 30) -> Trace: config = read_json_file(config_file) return generate_trace_from_config(config, duration)
def main(): args = parse_args() udr_large = read_json_file(args.config_file)[0] for i in range(10, 110, 10): set_seed(i) bw_upper_bnd_min, bw_upper_bnd_max = udr_large['bandwidth_upper_bound'] new_bw_upper_bnd_min, new_bw_upper_bnd_max = gen_random_range( 'bandwidth_upper_bound', bw_upper_bnd_min, bw_upper_bnd_max, True) bw_lower_bnd_min, bw_lower_bnd_max = udr_large['bandwidth_lower_bound'] new_bw_lower_bnd_min, new_bw_lower_bnd_max = gen_random_range( 'bandwidth_lower_bound', bw_lower_bnd_min, new_bw_upper_bnd_max, True) while new_bw_lower_bnd_min > new_bw_upper_bnd_min: new_bw_lower_bnd_min, new_bw_lower_bnd_max = gen_random_range( 'bandwidth_lower_bound', bw_lower_bnd_min, new_bw_upper_bnd_max, True) delay_min, delay_max = udr_large['delay'] new_delay_min, new_delay_max = gen_random_range( 'delay', delay_min, delay_max) loss_min, loss_max = udr_large['loss'] new_loss_min, new_loss_max = gen_random_range('loss', loss_min, loss_max, True) queue_min, queue_max = udr_large['queue'] new_queue_min, new_queue_max = gen_random_range( 'queue', queue_min, queue_max) T_s_min, T_s_max = udr_large['T_s'] new_T_s_min, new_T_s_max = gen_random_range('T_s', T_s_min, T_s_max) delay_noise_min, delay_noise_max = udr_large['delay_noise'] new_delay_noise_min, new_delay_noise_max = gen_random_range( 'delay_noise', delay_noise_min, delay_noise_max) udr_mid = copy.deepcopy(udr_large) udr_mid['bandwidth_lower_bound'][0] = new_bw_lower_bnd_min udr_mid['bandwidth_lower_bound'][1] = new_bw_lower_bnd_max udr_mid['bandwidth_upper_bound'][0] = new_bw_upper_bnd_min udr_mid['bandwidth_upper_bound'][1] = new_bw_upper_bnd_max udr_mid['delay'][0] = new_delay_min udr_mid['delay'][1] = new_delay_max udr_mid['loss'][0] = new_loss_min udr_mid['loss'][1] = new_loss_max udr_mid['queue'][0] = new_queue_min udr_mid['queue'][1] = new_queue_max udr_mid['T_s'][0] = new_T_s_min udr_mid['T_s'][1] = new_T_s_max udr_mid['delay_noise'][0] = new_delay_noise_min udr_mid['delay_noise'][1] = new_delay_noise_max write_json_file( os.path.join(args.save_dir, 'udr_mid_seed_{}.json'.format(i)), [udr_mid]) set_seed(i) bw_upper_bnd_min, bw_upper_bnd_max = udr_large['bandwidth_upper_bound'] new_bw_upper_bnd_min, new_bw_upper_bnd_max = gen_random_range( 'bandwidth_upper_bound', bw_upper_bnd_min, bw_upper_bnd_max, True, single_point=True) new_bw_lower_bnd_min, new_bw_lower_bnd_max = new_bw_upper_bnd_min, new_bw_upper_bnd_max delay_min, delay_max = udr_large['delay'] new_delay_min, new_delay_max = gen_random_range('delay', delay_min, delay_max, False, 1 / 9, single_point=True) loss_min, loss_max = udr_large['loss'] new_loss_min, new_loss_max = gen_random_range('loss', loss_min, loss_max, True, 1 / 9, single_point=True) queue_min, queue_max = udr_large['queue'] new_queue_min, new_queue_max = gen_random_range('queue', queue_min, queue_max, False, 1 / 9, single_point=True) T_s_min, T_s_max = udr_large['T_s'] new_T_s_min, new_T_s_max = gen_random_range('T_s', T_s_min, T_s_max, False, 1 / 9, single_point=True) delay_noise_min, delay_noise_max = udr_large['delay_noise'] new_delay_noise_min, new_delay_noise_max = gen_random_range( 'delay_noise', delay_noise_min, delay_noise_max, False, 1 / 9, single_point=True) udr_small = copy.deepcopy(udr_large) udr_small['bandwidth_lower_bound'][0] = new_bw_lower_bnd_min udr_small['bandwidth_lower_bound'][1] = new_bw_lower_bnd_max udr_small['bandwidth_upper_bound'][0] = new_bw_upper_bnd_min udr_small['bandwidth_upper_bound'][1] = new_bw_upper_bnd_max udr_small['delay'][0] = new_delay_min udr_small['delay'][1] = new_delay_max udr_small['loss'][0] = new_loss_min udr_small['loss'][1] = new_loss_max udr_small['queue'][0] = new_queue_min udr_small['queue'][1] = new_queue_max udr_small['T_s'][0] = new_T_s_min udr_small['T_s'][1] = new_T_s_max udr_small['delay_noise'][0] = new_delay_noise_min udr_small['delay_noise'][1] = new_delay_noise_max write_json_file( os.path.join(args.save_dir, 'udr_small_seed_{}.json'.format(i)), [udr_small])
def main(): args = parse_args() set_seed(args.seed) metric = args.dimension model_paths = args.model_path save_root = args.save_dir config_file = args.config_file train_config_dir = args.train_config_dir print(metric, model_paths, save_root, config_file) plt.figure(figsize=(8, 8)) config = read_json_file(config_file) print(config) bw_list = config['bandwidth'] delay_list = config['delay'] loss_list = config['loss'] queue_list = config["queue"] # run cubic cubic_rewards = [] # cubic_scores = [] for (bw, delay, loss, queue) in itertools.product( bw_list, delay_list, loss_list, queue_list): save_dir = f"{save_root}/rand_{metric}/env_{bw}_{delay}_{loss}_{queue}" cubic_save_dir = os.path.join(save_dir, "cubic") if not args.plot_only: t_start = time.time() cmd = "python evaluate_cubic.py --bandwidth {} --delay {} " \ "--loss {} --queue {} --save-dir {} --duration {} --seed {}".format( bw, delay, loss, queue, cubic_save_dir, args.duration, args.seed) subprocess.check_output(cmd, shell=True).strip() print("run cubic on bw={}Mbps, delay={}ms, loss={}, " "queue={}packets, duration={}s, used {:3f}s".format( bw, delay, loss, queue, args.duration, time.time() - t_start)) df = pd.read_csv(os.path.join( cubic_save_dir, "cubic_test_log.csv")) cubic_rewards.append(df['reward'].mean()) # cubic_scores.append(np.mean(learnability_objective_function( # df['throughput'] * 1500 * 8 / 1e6, df['latency']*1000/2))) for model_idx, (model_path, ls, marker, color) in enumerate( zip(model_paths, ["-", "--", "-.", "-", "-", "--", "-.", ":"], ["x", "s", "v", '*', '+', '^', '>', '1'], ["C3", "C3", "C3", "C1", "C1", "C1", "C1", "C1"])): model_name = os.path.basename(os.path.dirname(model_path)) aurora_rewards = [] # aurora_scores = [] # detect latest n models here last_n_model_paths = get_last_n_models(model_path, args.n_models) # construct n Aurora objects and load aurora models here last_n_auroras = [] for tmp_model_path in last_n_model_paths: last_n_auroras.append( Aurora(seed=args.seed, log_dir="", timesteps_per_actorbatch=10, pretrained_model_path=tmp_model_path, delta_scale=args.delta_scale)) for (bw, delay, loss, queue) in itertools.product( bw_list, delay_list, loss_list, queue_list): save_dir = f"{save_root}/rand_{metric}/env_{bw}_{delay}_{loss}_{queue}" aurora_save_dir = os.path.join(save_dir, model_name) cubic_save_dir = os.path.join(save_dir, "cubic") # run aurora aurora_rewards.append( multiple_runs(last_n_auroras, bw, delay, loss, queue, aurora_save_dir, args.duration, args.plot_only)) if model_idx == 0: plt.plot(config[metric], cubic_rewards, 'o-', c="C0", label="TCP Cubic") if train_config_dir is not None: train_config = read_json_file(os.path.join( train_config_dir, model_name+'.json')) env = 'bw=[{}, {}]Mbps, delay=[{}, {}]ms, loss=[{}, {}], queue=[{}, {}]pkt'.format( train_config[0]['bandwidth'][0], train_config[0]['bandwidth'][1], train_config[0]['delay'][0], train_config[0]['delay'][1], train_config[0]['loss'][0], train_config[0]['loss'][1], train_config[0]['queue'][0], train_config[0]['queue'][1]) else: env = "" # raise RuntimeError assert ls in {'', '-', '--', '-.', ':', None} plt.plot(config[metric], aurora_rewards, marker=marker, linestyle=ls, c=color, label=model_name + ", " + env) plt.legend(bbox_to_anchor=(0.0, 1.02, 1.0, 0.2), loc="lower left", mode="expand", ncol=1, ) if metric == "bandwidth": unit = "Mbps" elif metric == 'delay': unit = 'ms' elif metric == 'loss': unit = '' elif metric == 'queue': unit = 'packets' else: raise RuntimeError plt.xlabel("{} ({})".format(metric, unit)) plt.ylabel('Reward') # plt.ylabel('log(throughput) - log(delay)') plt.tight_layout() plt.savefig(os.path.join( args.save_dir, "rand_{}_sim.png".format(metric))) plt.close()
def main(): args = parse_args() dim0_vals, dim0_ticks, dim0_ticklabels, dim0_axlabel = get_dim_vals( args.dims[0]) dim1_vals, dim1_ticks, dim1_ticklabels, dim1_axlabel = get_dim_vals( args.dims[1]) fig, axes = plt.subplots(2, 5, figsize=(12, 10)) max_gap = np.NINF min_gap = np.inf # tokens = os.path.basename(os.path.dirname(args.root)).split('_') # overfit_config0_dim0_idx = int(tokens[1]) # overfit_config0_dim1_idx = int(tokens[2]) # overfit_config1_dim0_idx = int(tokens[4]) # overfit_config1_dim1_idx = int(tokens[5]) gap_matrices = [] with open('heatmap_trace_cnt_ratio.npy', 'rb') as f: cnt_ratio = np.load(f) bo_range = range(0, 30, 3) for bo in bo_range: results = [] std_mat = np.zeros((len(dim0_vals), len(dim1_vals))) for i in range(len(dim0_vals)): row = [] for j in range(len(dim1_vals)): # if (i != overfit_config0_dim0_idx and j != overfit_config0_dim1_idx) or (i != overfit_config1_dim0_idx and j != overfit_config1_dim1_idx): # continue gaps = [] cnt = 10 # if cnt_ratio[i, j] > 1: # cnt *= int(cnt_ratio[i, j]) for k in range(cnt): trace_dir = os.path.join( args.root, "{}_vs_{}/pair_{}_{}/trace_{}".format( args.dims[0], args.dims[1], i, j, k)) # if os.path.exists(os.path.join(trace_dir, args.heuristic, '{}_summary.csv'.format(args.heuristic))): # if (i == overfit_config0_dim0_idx and j == overfit_config0_dim1_idx): df = load_summary( os.path.join(trace_dir, args.heuristic, '{}_summary.csv'.format(args.heuristic))) # else: # df = {'{}_level_reward'.format( # args.reward_level): 0} heuristic_reward = df['{}_level_reward'.format( args.reward_level)] if args.rl == 'pretrained': df = load_summary( os.path.join(trace_dir, 'pretrained', 'aurora_summary.csv')) elif args.rl == 'overfit_config': if bo == 0: # if os.path.exists(os.path.join( # trace_dir, 'overfit_config', 'aurora_summary.csv')): # if (i == overfit_config0_dim0_idx and j == overfit_config0_dim1_idx): df = load_summary( os.path.join(trace_dir, 'overfit_config', 'aurora_summary.csv')) # else: # df = {'{}_level_reward'.format( # args.reward_level): 0} # elif bo == 3: # df = load_summary(os.path.join( # trace_dir, 'overfit_config', 'aurora_summary.csv')) else: continue else: df = load_summary( os.path.join(trace_dir, args.rl, 'seed_{}'.format(args.seed), "bo_{}".format(bo), 'step_64800', 'aurora_summary.csv')) genet_reward = df['{}_level_reward'.format( args.reward_level)] gaps.append(genet_reward - heuristic_reward) row.append(np.mean(gaps)) if np.mean(gaps) < 0: # std_mat[i, j] = int((compute_std_of_mean(gaps) / 12.5)**2) std_mat[i, j] = compute_std_of_mean(gaps) max_gap = max(max_gap, np.mean(gaps)) min_gap = min(min_gap, np.mean(gaps)) results.append(row) results = np.array(results) # with open('heatmap_trace_cnt_ratio.npy', 'wb') as f: # np.save(f, std_mat) gap_matrices.append(results) for subplot_idx, (gap_matrix, bo, ax) in enumerate( zip(gap_matrices, bo_range, axes.flatten())): im = ax.imshow(gap_matrix) im.set_clim(vmax=0, vmin=-200) if args.rl != 'pretrained' and args.rl != 'overfit_config': selected_configs = read_json_file( os.path.join(args.models_path, 'bo_{}.json'.format(bo))) selected_dim1_idxs = [] selected_dim0_idxs = [] for selected_config in selected_configs[1:]: selected_dim1_idxs.append( find_idx(selected_config[args.dims[1]][0], dim1_vals)) selected_dim0_idxs.append( find_idx(selected_config[args.dims[0]][0], dim0_vals)) ax.scatter(selected_dim1_idxs, selected_dim0_idxs, marker='o', c='r') if subplot_idx == 0 or subplot_idx == 5: ax.set_yticks(dim0_ticks) ax.set_yticklabels(dim0_ticklabels) ax.set_ylabel(dim0_axlabel) else: ax.set_yticks([]) ax.set_xticks(dim1_ticks) ax.set_xticklabels(dim1_ticklabels) if subplot_idx == 2 or subplot_idx == 7: ax.set_xlabel(dim1_axlabel) if args.rl == 'pretrained': ax.set_title("pretrained") # plt.savefig(os.path.join(args.root, '{}_vs_{}'.format(args.dims[0], args.dims[1]), # '{}_{}_{}_level_reward_heatmap.jpg'.format(args.rl, args.heuristic, args.reward_level))) break elif args.rl == 'overfit_config': tokens = os.path.basename(os.path.dirname(args.root)).split('_') overfit_config0_dim0_idx = int(tokens[1]) overfit_config0_dim1_idx = int(tokens[2]) # overfit_config1_dim0_idx = int(tokens[4]) # overfit_config1_dim1_idx = int(tokens[5]) ax.scatter(overfit_config0_dim1_idx, overfit_config0_dim0_idx, marker='.', c='r', s=2) # ax.scatter(overfit_config1_dim1_idx, overfit_config1_dim0_idx, marker='x', c='r', s=2) else: ax.set_title("BO {}".format(bo)) # plt.savefig(os.path.join(args.root, '{}_vs_{}'.format(args.dims[0], args.dims[1]), # '{}_{}_bo_{}_{}_level_reward_heatmap.jpg'.format(args.rl, args.heuristic, bo, args.reward_level))) cbar = fig.colorbar(im, ax=axes, location='bottom') cbar.ax.set_xlabel("{} - {}".format(args.rl, args.heuristic), rotation=0) # fig.tight_layout() plt.savefig( os.path.join( args.root, '{}_vs_{}'.format(args.dims[0], args.dims[1]), '{}_{}_{}_level_reward_seed_{}_heatmap.jpg'.format( args.rl, args.heuristic, args.reward_level, args.seed))) plt.close()