def main():
args = parse_args()
if args.trace_file and args.trace_file.endswith('.json'):
trace = Trace.load_from_file(args.trace_file)
elif args.trace_file and args.trace_file.endswith('.log'):
trace = Trace.load_from_pantheon_file(args.trace_file, 0, 50, 500)
else:
trace = None
for log_idx, log_file in enumerate(args.log_file):
if not os.path.exists(log_file):
continue
pkt_log = PacketLog.from_log_file(log_file, 500)
cc = os.path.splitext(os.path.basename(log_file))[0].split('_')[0]
sending_rate_ts, sending_rate = pkt_log.get_sending_rate()
throughput_ts, throughput = pkt_log.get_throughput()
rtt_ts, rtt = pkt_log.get_rtt()
# queue_delay_ts, queue_delay = pkt_log.get_queue_delay()
pkt_loss = pkt_log.get_loss_rate()
avg_tput = pkt_log.get_avg_throughput()
avg_sending_rate = pkt_log.get_avg_sending_rate()
avg_lat = pkt_log.get_avg_latency()
reward = pkt_log.get_reward("", None)
normalized_reward = pkt_log.get_reward("", trace)
plot(trace, throughput_ts, throughput, sending_rate_ts, sending_rate,
avg_tput, avg_sending_rate, rtt_ts, rtt, avg_lat, pkt_loss,
reward, normalized_reward, args.save_dir, cc)
def main():
args = parse_args()
assert args.pretrained_model_path is None or args.pretrained_model_path.endswith(
".ckpt")
os.makedirs(args.save_dir, exist_ok=True)
save_args(args)
set_seed(args.seed + COMM_WORLD.Get_rank() * 100)
nprocs = COMM_WORLD.Get_size()
# Initialize model and agent policy
aurora = Aurora(args.seed + COMM_WORLD.Get_rank() * 100, args.save_dir,
int(7200 / nprocs), args.pretrained_model_path,
tensorboard_log=args.tensorboard_log)
# training_traces, validation_traces,
training_traces = []
val_traces = []
if args.train_trace_file:
with open(args.train_trace_file, 'r') as f:
for line in f:
line = line.strip()
if args.dataset == 'pantheon':
queue = 100 # dummy value
# if "ethernet" in line:
# queue = 500
# elif "cellular" in line:
# queue = 50
# else:
# queue = 100
training_traces.append(Trace.load_from_pantheon_file(
line, queue=queue, loss=0))
elif args.dataset == 'synthetic':
training_traces.append(Trace.load_from_file(line))
else:
raise ValueError
if args.val_trace_file:
with open(args.val_trace_file, 'r') as f:
for line in f:
line = line.strip()
if args.dataset == 'pantheon':
queue = 100 # dummy value
# if "ethernet" in line:
# queue = 500
# elif "cellular" in line:
# queue = 50
# else:
# queue = 100
val_traces.append(Trace.load_from_pantheon_file(
line, queue=queue, loss=0))
elif args.dataset == 'synthetic':
val_traces.append(Trace.load_from_file(line))
else:
raise ValueError
print(args.randomization_range_file)
aurora.train(args.randomization_range_file,
args.total_timesteps, tot_trace_cnt=args.total_trace_count,
tb_log_name=args.exp_name, validation_flag=args.validation,
training_traces=training_traces,
validation_traces=val_traces)
def main():
args = parse_args()
for _, log_file in enumerate(args.log_file):
if not os.path.exists(log_file):
continue
if not args.trace_file:
trace = None
elif args.trace_file.endswith('.json'):
trace = Trace.load_from_file(args.trace_file)
elif args.trace_file.endswith('.log'):
trace = Trace.load_from_pantheon_file(args.trace_file,
loss=0,
queue=10)
else:
trace = None
cc = os.path.basename(log_file).split('_')[0]
plot(trace, log_file, args.save_dir, cc)
def load_from_dir(trace_dir: str):
files = sorted(glob.glob(os.path.join(trace_dir, 'trace_*.json')))
traces = []
for file in files:
traces.append(Trace.load_from_file(file))
dataset = SyntheticDataset(len(traces), None)
dataset.traces = traces
return dataset
def main():
args = parse_args()
bbr = BBR(False)
cubic = Cubic(False)
validation_traces = []
save_dirs = []
for i in range(20):
trace_file = os.path.join(args.save_dir, 'validation_traces',
"trace_{}.json".format(i))
if not os.path.exists(trace_file):
continue
validation_traces.append(Trace.load_from_file(trace_file))
save_dir = os.path.join(args.save_dir, 'validation_traces',
"trace_{}".format(i))
os.makedirs(save_dir, exist_ok=True)
save_dirs.append(save_dir)
bbr_trace_rewards = bbr.test_on_traces(validation_traces, save_dirs, False)
cubic_trace_rewards = cubic.test_on_traces(validation_traces, save_dirs,
False)
bbr_rewards = [mi_level_reward for mi_level_reward, _ in bbr_trace_rewards]
cubic_rewards = [
mi_level_reward for mi_level_reward, _ in cubic_trace_rewards
]
for log_file in args.log_file:
plt.figure()
model_name = log_file.split('/')[-2]
plt.title(model_name)
df = pd.read_csv(log_file, sep='\t')
best_step = int(
df['num_timesteps'][df['mean_validation_reward'].argmax()])
t_used = df['tot_t_used(min)'][df['mean_validation_reward'].argmax()]
best_reward = df['mean_validation_reward'].max()
best_model_path = os.path.join(
os.path.dirname(log_file),
"model_step_{}.ckpt.meta".format(best_step))
plt.plot(
df['num_timesteps'],
df['mean_validation_reward'],
'o-',
label="best_reward: {:.2f}, best step: {}, used {:.2f}min".format(
best_reward, int(best_step), t_used))
plt.axhline(y=np.mean(bbr_rewards), c='r', label='BBR')
plt.axhline(y=np.mean(cubic_rewards), c='k', label='Cubic')
plt.xlabel('Num steps')
plt.ylabel('Validation Reward')
plt.legend()
assert os.path.exists(best_model_path)
print(best_model_path.replace(".meta", ""))
if args.save_dir:
os.makedirs(args.save_dir, exist_ok=True)
plt.savefig(
os.path.join(args.save_dir,
'{}_val_curve.png'.format(model_name)))
plt.close()
def get_reward(self, trace_file: str, trace=None) -> float:
if trace_file and trace_file.endswith('.json'):
trace = Trace.load_from_file(trace_file)
elif trace_file and trace_file.endswith('.log'):
trace = Trace.load_from_pantheon_file(trace_file, 0, 50, 500)
loss = self.get_loss_rate()
if trace is None:
# original reward
return pcc_aurora_reward(
self.get_avg_throughput() * 1e6 / BITS_PER_BYTE /
BYTES_PER_PACKET,
self.get_avg_latency() / 1e3, loss)
# normalized reward
return pcc_aurora_reward(
self.get_avg_throughput() * 1e6 / BITS_PER_BYTE / BYTES_PER_PACKET,
self.get_avg_latency() / 1e3, loss,
trace.avg_bw * 1e6 / BITS_PER_BYTE / BYTES_PER_PACKET,
trace.min_delay * 2 / 1e3)
def load_from_file(trace_file: str):
traces = []
with open(trace_file, 'r') as f:
for line in f:
line = line.strip()
traces.append(Trace.load_from_file(line))
dataset = SyntheticDataset(len(traces), None)
dataset.traces = traces
return dataset
def main():
args = parse_args()
set_seed(args.seed)
if args.save_dir:
os.makedirs(args.save_dir, exist_ok=True)
if args.trace_file is not None and args.trace_file.endswith('.json'):
test_traces = [Trace.load_from_file(args.trace_file)]
elif args.trace_file is not None and args.trace_file.endswith('.log'):
test_traces = [
Trace.load_from_pantheon_file(args.trace_file, args.delay,
args.loss, args.queue)
]
elif args.config_file is not None:
test_traces = generate_traces(args.config_file,
1,
args.duration,
constant_bw=not args.time_variant_bw)
else:
test_traces = [
generate_trace((args.duration, args.duration),
(args.bandwidth, args.bandwidth),
(args.delay, args.delay), (args.loss, args.loss),
(args.queue, args.queue), (60, 60), (60, 60),
constant_bw=not args.time_variant_bw)
]
# print(test_traces[0].bandwidths)
aurora = Aurora(seed=args.seed,
timesteps_per_actorbatch=10,
log_dir=args.save_dir,
pretrained_model_path=args.model_path,
delta_scale=args.delta_scale)
results, pkt_logs = aurora.test_on_traces(test_traces, [args.save_dir])
for pkt_log in pkt_logs:
with open(os.path.join(args.save_dir, "aurora_packet_log.csv"), 'w',
1) as f:
pkt_logger = csv.writer(f, lineterminator='\n')
pkt_logger.writerows(pkt_log)
def main():
args = parse_args()
for trace_file in glob.glob(os.path.join(args.trace_dir, "*.json")):
trace_name = os.path.splitext(os.path.basename(trace_file))[0]
tr = Trace.load_from_file(trace_file)
ms_series = tr.convert_to_mahimahi_format()
with open(os.path.join(args.save_dir, trace_name), 'w', 1) as f:
for ms in ms_series:
f.write(str(ms) + '\n')
with open(os.path.join(args.save_dir, 'loss'), 'w', 1) as f:
f.write(str(tr.loss_rate))
with open(os.path.join(args.save_dir, 'queue'), 'w', 1) as f:
f.write(str(int(tr.queue_size)))
with open(os.path.join(args.save_dir, 'delay'), 'w', 1) as f:
f.write(str(int(np.mean(np.array(tr.delays)))))
rewards = []
for trace, log_file in zip(traces, log_files):
if not os.path.exists(log_file):
continue
pkt_log = PacketLog.from_log_file(log_file)
rewards.append(pkt_log.get_reward("", trace))
return rewards
traces = []
save_dirs = []
genet_save_dirs = []
for cc in TARGET_CCS:
print("Loading real traces collected by {}...".format(cc))
for trace_file in tqdm(sorted(glob.glob(os.path.join(
TRACE_ROOT, "{}_datalink_run[1,3].log".format(cc))))):
traces.append(Trace.load_from_pantheon_file(trace_file, 0.0, 50))
save_dirs.append(os.path.join(
RESULT_ROOT, EXP_NAME, os.path.basename(TRACE_ROOT),
os.path.splitext(os.path.basename(trace_file))[0]))
genet_save_dirs.append(os.path.join(
RESULT_ROOT, EXP_NAME1, os.path.basename(TRACE_ROOT),
os.path.splitext(os.path.basename(trace_file))[0]))
bbr_rewards = load_cc_rewards_across_traces(traces, [os.path.join(save_dir, "bbr", "bbr_packet_log.csv") for save_dir in save_dirs])
cubic_rewards = load_cc_rewards_across_traces(traces, [os.path.join(save_dir, "cubic", "cubic_packet_log.csv") for save_dir in save_dirs])
import pdb
pdb.set_trace()
genet_steps = []
genet_avg_rewards = []
for bo in range(6):
def test(self,
trace: Trace,
save_dir: str,
plot_flag: bool = False) -> Tuple[float, float]:
"""Test a network trace and return rewards.
The 1st return value is the reward in Monitor Interval(MI) level and
the length of MI is 1 srtt. The 2nd return value is the reward in
packet level. It is computed by using throughput, average rtt, and
loss rate in each 500ms bin of the packet log. The 2nd value will be 0
if record_pkt_log flag is False.
Args:
trace: network trace.
save_dir: where a MI level log will be saved if save_dir is a
valid path. A packet level log will be saved if record_pkt_log
flag is True and save_dir is a valid path.
"""
links = [Link(trace), Link(trace)]
senders = [BBRSender(0, 0, self.seed)]
net = Network(senders, links, self.record_pkt_log)
rewards = []
start_rtt = trace.get_delay(0) * 2 / 1000
run_dur = start_rtt
if save_dir:
os.makedirs(save_dir, exist_ok=True)
f_sim_log = open(
os.path.join(save_dir,
'{}_simulation_log.csv'.format(self.cc_name)),
'w', 1)
writer = csv.writer(f_sim_log, lineterminator='\n')
writer.writerow([
'timestamp', "send_rate", 'recv_rate', 'latency', 'loss',
'reward', "action", "bytes_sent", "bytes_acked", "bytes_lost",
"send_start_time", "send_end_time", 'recv_start_time',
'recv_end_time', 'latency_increase', "packet_size",
'bandwidth', "queue_delay", 'packet_in_queue', 'queue_size',
'cwnd', 'ssthresh', "rto", "packets_in_flight"
])
else:
f_sim_log = None
writer = None
while True:
net.run(run_dur)
mi = senders[0].get_run_data()
throughput = mi.get("recv rate") # bits/sec
send_rate = mi.get("send rate") # bits/sec
latency = mi.get("avg latency")
avg_queue_delay = mi.get("avg queue delay")
loss = mi.get("loss ratio")
reward = pcc_aurora_reward(
throughput / BITS_PER_BYTE / BYTES_PER_PACKET, latency, loss,
trace.avg_bw * 1e6 / BITS_PER_BYTE / BYTES_PER_PACKET)
rewards.append(reward)
try:
ssthresh = senders[0].ssthresh
except:
ssthresh = 0
action = 0
if save_dir and writer:
writer.writerow([
net.get_cur_time(), send_rate, throughput, latency, loss,
reward, action, mi.bytes_sent, mi.bytes_acked,
mi.bytes_lost, mi.send_start, mi.send_end, mi.recv_start,
mi.recv_end,
mi.get('latency increase'), mi.packet_size,
links[0].get_bandwidth(net.get_cur_time()) *
BYTES_PER_PACKET * BITS_PER_BYTE, avg_queue_delay,
links[0].pkt_in_queue, links[0].queue_size,
senders[0].cwnd, ssthresh, senders[0].rto,
senders[0].bytes_in_flight / BYTES_PER_PACKET
])
if senders[0].srtt:
run_dur = senders[0].srtt
should_stop = trace.is_finished(net.get_cur_time())
if should_stop:
break
if f_sim_log:
f_sim_log.close()
avg_sending_rate = senders[0].avg_sending_rate
tput = senders[0].avg_throughput
avg_lat = senders[0].avg_latency
loss = senders[0].pkt_loss_rate
pkt_level_reward = pcc_aurora_reward(tput,
avg_lat,
loss,
avg_bw=trace.avg_bw * 1e6 /
BITS_PER_BYTE / BYTES_PER_PACKET)
pkt_level_original_reward = pcc_aurora_reward(tput, avg_lat, loss)
if save_dir:
with open(
os.path.join(save_dir,
"{}_summary.csv".format(self.cc_name)),
'w') as f:
summary_writer = csv.writer(f, lineterminator='\n')
summary_writer.writerow([
'trace_average_bandwidth', 'trace_average_latency',
'average_sending_rate', 'average_throughput',
'average_latency', 'loss_rate', 'mi_level_reward',
'pkt_level_reward'
])
summary_writer.writerow([
trace.avg_bw, trace.avg_delay,
avg_sending_rate * BYTES_PER_PACKET * BITS_PER_BYTE / 1e6,
tput * BYTES_PER_PACKET * BITS_PER_BYTE / 1e6, avg_lat,
loss,
np.mean(rewards), pkt_level_reward
])
if self.record_pkt_log and save_dir:
with open(
os.path.join(save_dir,
"{}_packet_log.csv".format(self.cc_name)),
'w', 1) as f:
pkt_logger = csv.writer(f, lineterminator='\n')
pkt_logger.writerow([
'timestamp', 'packet_event_id', 'event_type', 'bytes',
'cur_latency', 'queue_delay', 'packet_in_queue',
'sending_rate', 'bandwidth'
])
pkt_logger.writerows(net.pkt_log)
# with open(os.path.join(save_dir, "{}_log.csv".format(self.cc_name)), 'w', 1) as f:
# writer = csv.writer(f, lineterminator='\n')
# writer.writerow(
# ['timestamp', 'pacing_gain', "pacing_rate", 'cwnd_gain',
# 'cwnd', 'target_cwnd', 'prior_cwnd', "btlbw", "rtprop",
# "full_bw", 'state', "packets_in_flight",
# "in_fast_recovery_mode", 'rs_delivery_rate', 'round_start',
# 'round_count', 'rto', 'exit_fast_recovery_ts',
# 'pkt_in_queue'])
# writer.writerows(senders[0].bbr_log)
if plot_flag and save_dir:
plot_mi_level_time_series(
trace,
os.path.join(save_dir,
'{}_simulation_log.csv'.format(self.cc_name)),
save_dir, self.cc_name)
plot(trace, *senders[0].bin_tput, *senders[0].bin_sending_rate,
tput * BYTES_PER_PACKET * BITS_PER_BYTE / 1e6,
avg_sending_rate * BYTES_PER_PACKET * BITS_PER_BYTE / 1e6,
*senders[0].latencies, avg_lat * 1000, loss,
pkt_level_original_reward, pkt_level_reward, save_dir,
self.cc_name)
return np.mean(rewards), pkt_level_reward
def main():
args = parse_args()
assert (not args.pretrained_model_path
or args.pretrained_model_path.endswith(".ckpt"))
os.makedirs(args.save_dir, exist_ok=True)
save_args(args, args.save_dir)
set_seed(args.seed + COMM_WORLD.Get_rank() * 100)
nprocs = COMM_WORLD.Get_size()
# Initialize model and agent policy
aurora = Aurora(
args.seed + COMM_WORLD.Get_rank() * 100,
args.save_dir,
int(args.val_freq / nprocs),
args.pretrained_model_path,
tensorboard_log=args.tensorboard_log,
)
# training_traces, validation_traces,
training_traces = []
val_traces = []
if args.curriculum == "udr":
config_file = args.config_file
if args.train_trace_file:
with open(args.train_trace_file, "r") as f:
for line in f:
line = line.strip()
training_traces.append(Trace.load_from_file(line))
if args.validation and args.val_trace_file:
with open(args.val_trace_file, "r") as f:
for line in f:
line = line.strip()
if args.dataset == "pantheon":
queue = 100 # dummy value
val_traces.append(
Trace.load_from_pantheon_file(line,
queue=queue,
loss=0))
elif args.dataset == "synthetic":
val_traces.append(Trace.load_from_file(line))
else:
raise ValueError
train_scheduler = UDRTrainScheduler(
config_file,
training_traces,
percent=args.real_trace_prob,
)
elif args.curriculum == "cl1":
config_file = args.config_files[0]
train_scheduler = CL1TrainScheduler(args.config_files, aurora)
elif args.curriculum == "cl2":
config_file = args.config_file
train_scheduler = CL2TrainScheduler(config_file, aurora, args.baseline)
else:
raise NotImplementedError
aurora.train(
config_file,
args.total_timesteps,
train_scheduler,
tb_log_name=args.exp_name,
validation_traces=val_traces,
)
"bandwidth": [0, 1, 2, 3, 4, 5, 6],
"delay": [5, 50, 100, 150, 200],
"loss": [0, 0.01, 0.02, 0.03, 0.04, 0.05],
"queue": [2, 10, 50, 100, 150, 200],
"T_s": [0, 1, 2, 3, 4, 5, 6],
"delay_noise": [0, 20, 40, 60, 80, 100],
}
real_traces = []
for trace_file in glob.glob(os.path.join(REAL_TRACE_DIR, "*datalink_run*.log")):
if 'bbr' not in trace_file and 'cubic' not in trace_file and \
'vegas' not in trace_file and 'pcc' not in trace_file and 'copa' not in trace_file:
continue
if 'experimental' in trace_file:
continue
tr = Trace.load_from_pantheon_file(trace_file, 50, 0, int(np.random.uniform(10, 10, 1).item()))
print(tr.delays)
print(min(tr.bandwidths), max(tr.bandwidths))
real_traces.append(tr)
syn_traces = [generate_trace(duration_range=(30, 30),
bandwidth_range=(1, 3),
delay_range=(30, 50),
# delay_range=(100, 200),
loss_rate_range=(0, 0),
queue_size_range=(10, 60),
T_s_range=(1, 3),
delay_noise_range=(0, 0),
constant_bw=False) for _ in range(15)]
import csv
from simulator.trace import Trace
from common.utils import write_json_file
for i in range(5):
timestamps = []
bandwidths = []
delays = []
queue = 2
loss = 0
delay_noise = 0
with open('test_aws_new/run{}/delay_time_series.csv'.format(i), 'r') as f:
reader = csv.reader(f)
for cols in reader:
timestamps.append(float(cols[0]))
delays.append(float(cols[1]))
bandwidths.append(0.6)
tr = Trace(timestamps, bandwidths, delays, loss, queue, delay_noise)
tr.dump('test_aws_new/run{}/trace.json'.format(i))