def __init__(self, log_dir='', train=False, random_seed=0): all_cooked_time, all_cooked_bw, _ = load_trace.load_trace(TRAIN_TRACES) self.all_cooked_time = all_cooked_time self.all_cooked_bw = all_cooked_bw self.observation_space = spaces.Box(low=np.repeat(-np.inf, 70), high=np.repeat(np.inf, 70)) # self.action_space = spaces.Box(low=-3.7,high=3.7,shape=(1,),dtype=np.float32) self.action_space = spaces.Discrete(8) self.cnt = 0 self.train = train self.log_dir = log_dir self.seed()
import LiveStreamingEnv.final_env as env import LiveStreamingEnv.load_trace as load_trace #import matplotlib.pyplot as plt import time import numpy as np # path setting TRAIN_TRACES = './network_trace/' #train trace path setting, #video_size_file = './video_trace/AsianCup_China_Uzbekistan/frame_trace_' #video trace path setting, video_size_file = './video_trace/frame_trace_' #video trace path setting, LogFile_Path = "./log/" #log file trace path setting, # Debug Mode: if True, You can see the debug info in the logfile # if False, no log ,but the training speed is high DEBUG = True DRAW = False # load the trace all_cooked_time, all_cooked_bw, all_file_names = load_trace.load_trace(TRAIN_TRACES) #random_seed random_seed = 2 video_count = 0 #FPS = 25 frame_time_len = 0.04 #init the environment #setting one: # 1,all_cooked_time : timestamp # 2,all_cooked_bw : throughput # 3,all_cooked_rtt : rtt # 4,agent_id : random_seed # 5,logfile_path : logfile_path # 6,VIDEO_SIZE_FILE : Video Size File Path # 7,Debug Setting : Debug net_env = env.Environment(all_cooked_time=all_cooked_time,
import time import numpy as np import random from PR_DQN import DQNPrioritizedReplay from sklearn import preprocessing # path setting TRAIN_TRACES = './train_sim_traces/' #train trace path setting, video_size_file = './video_size_' #video trace path setting, LogFile_Path = './Log/' #log file trace path setting, # Debug Mode: if True, You can see the debug info in the logfile # if False, no log ,but the training speed is high DEBUG = False DRAW = False # load the trace all_cooked_time, all_cooked_bw, all_cooked_rtt, _ = load_trace.load_trace( TRAIN_TRACES) #random_seed random_seed = 2 BIT_RATE = [500, 800] # kpbs TARGET_BUFFER = [2, 3] # seconds MAX_EPISODES = 30 RL = DQNPrioritizedReplay( len(BIT_RATE) * len(TARGET_BUFFER), 10, learning_rate=0.01, reward_decay=0.9, e_greedy=0.9, replace_target_iter=200, memory_size=2000,
def test(user_id): #TRAIN_TRACES = '/home/game/test_sim_traces/' #train trace path setting, #video_size_file = '/home/game/video_size_' #video trace path setting, #LogFile_Path = "/home/game/log/" #log file trace path setting, TRAIN_TRACES = './network_trace_2/' #train trace path setting, #video_size_file = './video_trace/AsianCup_China_Uzbekistan/frame_trace_' #video trace path setting, #video_size_file = './video_trace/Fengtimo_2018_11_3/frame_trace_' #video trace path setting, #video_size_file = './video_trace/YYF_2018_08_12/frame_trace_' #video trace path setting, #video_size_file = './video_trace_2/game/frame_trace_' video_size_file = './video_trace_2/room/frame_trace_' #video_size_file = './video_trace_2/sports/frame_trace_' LogFile_Path = "./log/" #log file trace path setting, # Debug Mode: if True, You can see the debug info in the logfile # if False, no log ,but the training speed is high DEBUG = False # load the trace all_cooked_time, all_cooked_bw, all_file_names = load_trace.load_trace( TRAIN_TRACES) #random_seed random_seed = 2 count = 0 video_count = 0 FPS = 25 frame_time_len = 0.04 reward_all_sum = 0 #init #setting one: # 1,all_cooked_time : timestamp # 2,all_cooked_bw : throughput # 3,all_cooked_rtt : rtt # 4,agent_id : random_seed # 5,logfile_path : logfile_path # 6,VIDEO_SIZE_FILE : Video Size File Path # 7,Debug Setting : Debug net_env = fixed_env.Environment(all_cooked_time=all_cooked_time, all_cooked_bw=all_cooked_bw, random_seed=random_seed, logfile_path=LogFile_Path, VIDEO_SIZE_FILE=video_size_file, Debug=DEBUG) abr_return = ABR_RETURN.Algorithm() abr_return_init = abr_return.Initial() abr = ABR.Algorithm() abr_init = abr.Initial() BIT_RATE = [500.0, 850.0, 1200.0, 1850.0] # kpbs TARGET_BUFFER = [2.0, 3.0] # seconds # ABR setting RESEVOIR = 0.5 CUSHION = 2 cnt = 0 # defalut setting last_bit_rate = 0 bit_rate = 0 target_buffer = 0 th_list = [0] * 5 buffer, cdn_count = 0, 0 debug_list = [['time','throughput','time_interval', 'send_data_size', 'chunk_len',\ 'rebuf', 'buffer_size', 'play_time_len','end_delay',\ 'cdn_newest_id', 'download_id', 'cdn_has_frame', 'decision_flag',\ 'buffer_flag', 'cdn_flag', 'end_of_video']] wr = [[ 'time', 'prediction_bitrate', 'next_segment_rate', 'segment_rate', 'cdn_list', 'ave_th', 'curr_th', 'th_10', 'th_20', 'th_30', 'th_40', 'th_50', 'buffer', 'cdn_buffer', 'buffer_flag', 'cdn_flag', 'cdn_count', 'end_delay', 'cdn_newest_id', 'download_id', 'bit_rate', 'qoe_label', 'qoe_1', 'qoe_2', 'qoe_3', 'qoe_4' ]] # QOE setting reward_frame = 0 reward_all = 0 reward_all_1, reward_all_2, reward_all_3, reward_all_4 = 0, 0, 0, 0 last_reward_all_1, last_reward_all_2, last_reward_all_3, last_reward_all_4 = 0, 0, 0, 0 last_segment_reward = 0 ll_segment_info = [0] * 8 SMOOTH_PENALTY = 0.02 REBUF_PENALTY = 1.5 LANTENCY_PENALTY = 0.005 # past_info setting past_frame_num = 7500 S_time_interval = [0] * past_frame_num S_send_data_size = [0] * past_frame_num S_chunk_len = [0] * past_frame_num S_rebuf = [0] * past_frame_num S_buffer_size = [0] * past_frame_num S_end_delay = [0] * past_frame_num S_chunk_size = [0] * past_frame_num S_play_time_len = [0] * past_frame_num S_decision_flag = [0] * past_frame_num S_buffer_flag = [0] * past_frame_num S_cdn_flag = [0] * past_frame_num # params setting is_terminated = False cnt_segment = 0 #q_table = pd.read_csv('qtable.csv',names=actions,header=0) while True: reward_frame = 0 reward_1, reward_2, reward_3, reward_4 = 0, 0, 0, 0 # input the train steps #if cnt > 5000: #plt.ioff() # break #actions bit_rate target_buffer # every steps to call the environment # time : physical time # time_interval : time duration in this step # send_data_size : download frame data size in this step # chunk_len : frame time len # rebuf : rebuf time in this step # buffer_size : current client buffer_size in this step # rtt : current buffer in this step # play_time_len : played time len in this step # end_delay : end to end latency which means the (upload end timestamp - play end timestamp) # decision_flag : Only in decision_flag is True ,you can choose the new actions, other time can't Becasuse the Gop is consist by the I frame and P frame. Only in I frame you can skip your frame # buffer_flag : If the True which means the video is rebuffing , client buffer is rebuffing, no play the video # cdn_flag : If the True cdn has no frame to get # end_of_video : If the True ,which means the video is over. time,time_interval, send_data_size, chunk_len,\ rebuf, buffer_size, play_time_len,end_delay,\ cdn_newest_id, download_id, cdn_has_frame, decision_flag,\ buffer_flag, cdn_flag, end_of_video = net_env.get_video_frame(bit_rate,target_buffer) if time_interval != 0: throughput = send_data_size / time_interval / 1000 else: throughput = 0 debug_list.append([time,throughput,time_interval, send_data_size, chunk_len,\ rebuf, buffer_size, play_time_len,end_delay,\ cdn_newest_id, download_id, cdn_has_frame, decision_flag,\ buffer_flag, cdn_flag, end_of_video]) # S_info is sequential order S_time_interval.pop(0) S_send_data_size.pop(0) S_chunk_len.pop(0) S_buffer_size.pop(0) S_rebuf.pop(0) S_end_delay.pop(0) S_play_time_len.pop(0) S_decision_flag.pop(0) S_buffer_flag.pop(0) S_cdn_flag.pop(0) S_time_interval.append(time_interval) S_send_data_size.append(send_data_size) S_chunk_len.append(chunk_len) S_buffer_size.append(buffer_size) S_rebuf.append(rebuf) S_end_delay.append(end_delay) S_play_time_len.append(play_time_len) S_decision_flag.append(decision_flag) S_buffer_flag.append(buffer_flag) S_cdn_flag.append(cdn_flag) # QOE setting if not cdn_flag: reward_frame = frame_time_len * float( BIT_RATE[bit_rate] ) / 1000 - REBUF_PENALTY * rebuf - LANTENCY_PENALTY * end_delay reward_1 = frame_time_len * float(BIT_RATE[bit_rate]) / 1000 reward_2 = REBUF_PENALTY * rebuf reward_3 = LANTENCY_PENALTY * end_delay else: reward_frame = -(REBUF_PENALTY * rebuf) reward_1 = 0 reward_2 = REBUF_PENALTY * rebuf reward_3 = 0 if decision_flag or end_of_video: cnt_segment += 1 # reward formate = play_time * BIT_RATE - 4.3 * rebuf - 1.2 * end_delay reward_frame += -1 * SMOOTH_PENALTY * ( abs(BIT_RATE[bit_rate] - BIT_RATE[last_bit_rate]) / 1000) reward_4 = 1 * SMOOTH_PENALTY * ( abs(BIT_RATE[bit_rate] - BIT_RATE[last_bit_rate]) / 1000) # last_bit_rate #print(len(th_list),th_list) reward_temp_1 = -last_reward_all_1 + reward_all_1 reward_temp_2 = last_reward_all_2 - reward_all_2 reward_temp_3 = last_reward_all_3 - reward_all_3 reward_temp_4 = last_reward_all_4 - reward_all_4 last_bit_rate = bit_rate last_reward_all_1 = reward_all_1 last_reward_all_2 = reward_all_2 last_reward_all_3 = reward_all_3 last_reward_all_4 = reward_all_4 #==================================Q_learning============================== """ action = last_bit_rate state = cnt_segment - 1 next_state = cnt_segment R = last_segment_reward R = R - 0.1*abs(buffer_size-2.35) q_predict = q_table.loc[state, str(action)] if end_of_video:#state != stop_count: q_target = R + GAMMA * q_table.iloc[next_state, :].max() # next state is not terminal else: q_target = R # next state is terminal is_terminated = True # terminate this episode q_table.loc[state, str(action)] += ALPHA * (q_target - q_predict) #q_table.loc[state, str(action)] = R if is_terminated: #print(q_table) q_table.to_csv('qtable.csv') break state_actions = q_table.iloc[next_state, :] if (np.random.uniform() > EPSILON) or ((state_actions == 0).all()): # act non-greedy or state-action have no value action_name = np.random.choice(actions) else: # act greedy action_name = state_actions.idxmax() # replace argmax to idxmax as argmax means a different function in newer version of pandas #print(state,action,R,next_state,q_table.loc[state, str(action)],action_name) #print(q_table) #==================================Q_learnign=========================== """ # -------------------------------------------Your Althgrithom ------------------------------------------- # which part is the althgrothm part ,the buffer based , # if the buffer is enough ,choose the high quality # if the buffer is danger, choose the low quality # if there is no rebuf ,choose the low target_buffer th_list, buffer, cdn_count, prediction_bitrate, segment_rate, ave_th, curr_th, next_sg_rate = abr_return.run( time, S_time_interval, S_send_data_size, S_chunk_len, S_rebuf, S_buffer_size, S_play_time_len, S_end_delay, S_decision_flag, S_buffer_flag, S_cdn_flag, end_of_video, cdn_newest_id, download_id, cdn_has_frame, abr_init) bit_rate, target_buffer = abr.run( time, S_time_interval, S_send_data_size, S_chunk_len, S_rebuf, S_buffer_size, S_play_time_len, S_end_delay, S_decision_flag, S_buffer_flag, S_cdn_flag, end_of_video, cdn_newest_id, download_id, cdn_has_frame, abr_init) last_segment_info = ll_segment_info + [ last_segment_reward, reward_temp_1, reward_temp_2, reward_temp_3, reward_temp_4 ] #print(end_delay,cdn_newest_id,download_id) wr.append(last_segment_info) #bit_rate = int(action_name) ll_segment_info = [ time, prediction_bitrate, next_sg_rate, segment_rate, cdn_has_frame, ave_th, curr_th, th_list[0], th_list[1], th_list[2], th_list[3], th_list[4], buffer, end_delay - buffer + 0.04, buffer_flag, cdn_flag, cdn_count, end_delay, cdn_newest_id, download_id, bit_rate ] last_segment_reward = 0 # ------------------------------------------- End ------------------------------------------- if end_of_video: q_table.to_csv('qtable.csv') print("video count", video_count, reward_all, reward_all_1, reward_all_2, reward_all_3, reward_all_4) reward_all_sum += reward_all / 1000 video_count += 1 if video_count >= 1: #len(all_file_names): break cnt = 0 last_bit_rate = 0 reward_all = 0 reward_all_1, reward_all_2, reward_all_3, reward_all_4 = 0, 0, 0, 0 bit_rate = 0 target_buffer = 0 S_time_interval = [0] * past_frame_num S_send_data_size = [0] * past_frame_num S_chunk_len = [0] * past_frame_num S_rebuf = [0] * past_frame_num S_buffer_size = [0] * past_frame_num S_end_delay = [0] * past_frame_num S_chunk_size = [0] * past_frame_num S_play_time_len = [0] * past_frame_num S_decision_flag = [0] * past_frame_num S_buffer_flag = [0] * past_frame_num S_cdn_flag = [0] * past_frame_num reward_all += reward_frame last_segment_reward += reward_frame reward_all_1 += reward_1 reward_all_2 += reward_2 reward_all_3 += reward_3 reward_all_4 += reward_4 with open('MPC_train.csv', 'w', newline='') as f: # 如果不指定newline='',则每写入一行将有一空行被写入 writer = csv.writer(f) writer.writerows(wr) """ with open('debug.csv', 'w', newline='') as d: # 如果不指定newline='',则每写入一行将有一空行被写入 writer = csv.writer(d) writer.writerows(debug_list) """ return reward_all_sum
def test(user_id): #TRAIN_TRACES = '/home/game/test_sim_traces/' #train trace path setting, #video_size_file = '/home/game/video_size_' #video trace path setting, #LogFile_Path = "/home/game/log/" #log file trace path setting, TRAIN_TRACES = './network_trace_2/' #train trace path setting, #video_size_file = './video_trace/AsianCup_China_Uzbekistan/frame_trace_' #video trace path setting, #video_size_file = './video_trace/Fengtimo_2018_11_3/frame_trace_' #video trace path setting, #video_size_file = './video_trace/YYF_2018_08_12/frame_trace_' #video trace path setting, #video_size_file = './video_trace_2/game/frame_trace_' video_size_file = './video_trace_2/room/frame_trace_' #video_size_file = './video_trace_2/sports/frame_trace_' #video_size_file = './video_trace_3/game_1/frame_trace_' #video_size_file = './video_trace_3/room_5/frame_trace_' #video_size_file = './video_trace_3/sports_4/frame_trace_' LogFile_Path = "./log/" #log file trace path setting, # Debug Mode: if True, You can see the debug info in the logfile # if False, no log ,but the training speed is high DEBUG = False # load the trace all_cooked_time, all_cooked_bw, all_file_names = load_trace.load_trace( TRAIN_TRACES) #random_seed random_seed = 2 count = 0 video_count = 0 FPS = 25 frame_time_len = 0.04 reward_all_sum = 0 #init #setting one: # 1,all_cooked_time : timestamp # 2,all_cooked_bw : throughput # 3,all_cooked_rtt : rtt # 4,agent_id : random_seed # 5,logfile_path : logfile_path # 6,VIDEO_SIZE_FILE : Video Size File Path # 7,Debug Setting : Debug net_env = fixed_env.Environment(all_cooked_time=all_cooked_time, all_cooked_bw=all_cooked_bw, random_seed=random_seed, logfile_path=LogFile_Path, VIDEO_SIZE_FILE=video_size_file, Debug=DEBUG) abr = ABR.Algorithm() abr_init = abr.Initial() BIT_RATE = [500.0, 850.0, 1200.0, 1850.0] # kpbs TARGET_BUFFER = [2.0, 3.0] # seconds # ABR setting RESEVOIR = 0.5 CUSHION = 2 cnt = 0 # defalut setting last_bit_rate = 0 bit_rate = 0 target_buffer = 0 # QOE setting reward_frame = 0 reward_all = 0 SMOOTH_PENALTY = 0.02 REBUF_PENALTY = 1.5 LANTENCY_PENALTY = 0.005 # past_info setting past_frame_num = 7500 S_time_interval = [0] * past_frame_num S_send_data_size = [0] * past_frame_num S_chunk_len = [0] * past_frame_num S_rebuf = [0] * past_frame_num S_buffer_size = [0] * past_frame_num S_end_delay = [0] * past_frame_num S_chunk_size = [0] * past_frame_num S_play_time_len = [0] * past_frame_num S_decision_flag = [0] * past_frame_num S_buffer_flag = [0] * past_frame_num S_cdn_flag = [0] * past_frame_num # params setting while True: reward_frame = 0 # input the train steps #if cnt > 5000: #plt.ioff() # break #actions bit_rate target_buffer # every steps to call the environment # time : physical time # time_interval : time duration in this step # send_data_size : download frame data size in this step # chunk_len : frame time len # rebuf : rebuf time in this step # buffer_size : current client buffer_size in this step # rtt : current buffer in this step # play_time_len : played time len in this step # end_delay : end to end latency which means the (upload end timestamp - play end timestamp) # decision_flag : Only in decision_flag is True ,you can choose the new actions, other time can't Becasuse the Gop is consist by the I frame and P frame. Only in I frame you can skip your frame # buffer_flag : If the True which means the video is rebuffing , client buffer is rebuffing, no play the video # cdn_flag : If the True cdn has no frame to get # end_of_video : If the True ,which means the video is over. time,time_interval, send_data_size, chunk_len,\ rebuf, buffer_size, play_time_len,end_delay,\ cdn_newest_id, download_id, cdn_has_frame, decision_flag,\ buffer_flag, cdn_flag, end_of_video = net_env.get_video_frame(bit_rate,target_buffer) # S_info is sequential order S_time_interval.pop(0) S_send_data_size.pop(0) S_chunk_len.pop(0) S_buffer_size.pop(0) S_rebuf.pop(0) S_end_delay.pop(0) S_play_time_len.pop(0) S_decision_flag.pop(0) S_buffer_flag.pop(0) S_cdn_flag.pop(0) S_time_interval.append(time_interval) S_send_data_size.append(send_data_size) S_chunk_len.append(chunk_len) S_buffer_size.append(buffer_size) S_rebuf.append(rebuf) S_end_delay.append(end_delay) S_play_time_len.append(play_time_len) S_decision_flag.append(decision_flag) S_buffer_flag.append(buffer_flag) S_cdn_flag.append(cdn_flag) # QOE setting if not cdn_flag: reward_frame = frame_time_len * float( BIT_RATE[bit_rate] ) / 1000 - REBUF_PENALTY * rebuf - LANTENCY_PENALTY * end_delay else: reward_frame = -(REBUF_PENALTY * rebuf) if decision_flag or end_of_video: # reward formate = play_time * BIT_RATE - 4.3 * rebuf - 1.2 * end_delay reward_frame += -1 * SMOOTH_PENALTY * ( abs(BIT_RATE[bit_rate] - BIT_RATE[last_bit_rate]) / 1000) # last_bit_rate last_bit_rate = bit_rate # -------------------------------------------Your Althgrithom ------------------------------------------- # which part is the althgrothm part ,the buffer based , # if the buffer is enough ,choose the high quality # if the buffer is danger, choose the low quality # if there is no rebuf ,choose the low target_buffer bit_rate, target_buffer = abr.run( time, S_time_interval, S_send_data_size, S_chunk_len, S_rebuf, S_buffer_size, S_play_time_len, S_end_delay, S_decision_flag, S_buffer_flag, S_cdn_flag, end_of_video, cdn_newest_id, download_id, cdn_has_frame, abr_init) #print(bit_rate,time) # ------------------------------------------- End ------------------------------------------- if end_of_video: print("video count", video_count, reward_all) reward_all_sum += reward_all / 1000 video_count += 1 if video_count >= len(all_file_names): break cnt = 0 last_bit_rate = 0 reward_all = 0 bit_rate = 0 target_buffer = 0 S_time_interval = [0] * past_frame_num S_send_data_size = [0] * past_frame_num S_chunk_len = [0] * past_frame_num S_rebuf = [0] * past_frame_num S_buffer_size = [0] * past_frame_num S_end_delay = [0] * past_frame_num S_chunk_size = [0] * past_frame_num S_play_time_len = [0] * past_frame_num S_decision_flag = [0] * past_frame_num S_buffer_flag = [0] * past_frame_num S_cdn_flag = [0] * past_frame_num reward_all += reward_frame return reward_all_sum
def test(user_id): #TRAIN_TRACES = '/home/game/test_sim_traces/' #train trace path setting, #video_size_file = '/home/game/video_size_' #video trace path setting, #LogFile_Path = "/home/game/log/" #log file trace path setting, TRAIN_TRACES = './network_trace/' #train trace path setting, video_size_file = './video_trace/AsianCup_China_Uzbekistan/frame_trace_' #video trace path setting, LogFile_Path = "./log/" #log file trace path setting, # Debug Mode: if True, You can see the debug info in the logfile # if False, no log ,but the training speed is high DEBUG = False DRAW = False # load the trace all_cooked_time, all_cooked_bw, all_file_names = load_trace.load_trace(TRAIN_TRACES) #random_seed random_seed = 2 count = 0 video_count = 0 FPS = 25 frame_time_len = 0.04 reward_all_sum = 0 #init #setting one: # 1,all_cooked_time : timestamp # 2,all_cooked_bw : throughput # 3,all_cooked_rtt : rtt # 4,agent_id : random_seed # 5,logfile_path : logfile_path # 6,VIDEO_SIZE_FILE : Video Size File Path # 7,Debug Setting : Debug net_env = fixed_env.Environment(all_cooked_time=all_cooked_time, all_cooked_bw=all_cooked_bw, random_seed=random_seed, logfile_path=LogFile_Path, VIDEO_SIZE_FILE=video_size_file, Debug = DEBUG) BIT_RATE = [500.0,850.0,1200.0,1850.0] # kpbs TARGET_BUFFER = [2.0,3.0] # seconds # ABR setting RESEVOIR = 0.5 CUSHION = 2 cnt = 0 # defalut setting last_bit_rate = 0 bit_rate = 0 target_buffer = 0 # QOE setting reward_frame = 0 reward_all = 0 SMOOTH_PENALTY= 0.02 REBUF_PENALTY = 1.5 LANTENCY_PENALTY = 0.005 # past_info setting past_frame_num = 7500 S_time_interval = [0] * past_frame_num S_send_data_size = [0] * past_frame_num S_chunk_len = [0] * past_frame_num S_rebuf = [0] * past_frame_num S_buffer_size = [0] * past_frame_num S_end_delay = [0] * past_frame_num S_chunk_size = [0] * past_frame_num S_play_time_len = [0] * past_frame_num S_decision_flag = [0] * past_frame_num S_buffer_flag = [0] * past_frame_num S_cdn_flag = [0] * past_frame_num S_bitrate = [0,0] # params setting # plot info idx = 0 id_list = [] bit_rate_record = [] buffer_record = [] throughput_record = [] # plot the real time image if DRAW: fig = plt.figure() plt.ion() plt.xlabel("time") plt.axis('off') while True: reward_frame = 0 # input the train steps #if cnt > 5000: #plt.ioff() # break #actions bit_rate target_buffer # every steps to call the environment # time : physical time # time_interval : time duration in this step # send_data_size : download frame data size in this step # chunk_len : frame time len # rebuf : rebuf time in this step # buffer_size : current client buffer_size in this step # rtt : current buffer in this step # play_time_len : played time len in this step # end_delay : end to end latency which means the (upload end timestamp - play end timestamp) # decision_flag : Only in decision_flag is True ,you can choose the new actions, other time can't Becasuse the Gop is consist by the I frame and P frame. Only in I frame you can skip your frame # buffer_flag : If the True which means the video is rebuffing , client buffer is rebuffing, no play the video # cdn_flag : If the True cdn has no frame to get # end_of_video : If the True ,which means the video is over. time,time_interval, send_data_size, chunk_len,\ rebuf, buffer_size, play_time_len,end_delay,\ cdn_newest_id, download_id, cdn_has_frame, decision_flag,\ buffer_flag, cdn_flag, end_of_video = net_env.get_video_frame(bit_rate,target_buffer) # S_info is sequential order S_time_interval.pop(0) S_send_data_size.pop(0) S_chunk_len.pop(0) S_buffer_size.pop(0) S_rebuf.pop(0) S_end_delay.pop(0) S_play_time_len.pop(0) S_decision_flag.pop(0) S_buffer_flag.pop(0) S_cdn_flag.pop(0) S_time_interval.append(time_interval) S_send_data_size.append(send_data_size) S_chunk_len.append(chunk_len) S_buffer_size.append(buffer_size) S_rebuf.append(rebuf) S_end_delay.append(end_delay) S_play_time_len.append(play_time_len) S_decision_flag.append(decision_flag) S_buffer_flag.append(buffer_flag) S_cdn_flag.append(cdn_flag) ''' if time_interval != 0: # plot bit_rate id_list.append(idx) idx += time_interval bit_rate_record.append(BIT_RATE[bit_rate]) # plot buffer buffer_record.append(buffer_size) # plot throughput trace_idx = net_env.get_trace_id() #print(trace_idx, idx,len(all_cooked_bw[trace_idx])) throughput_record.append(all_cooked_bw[trace_idx][int(idx/0.5)] % 2940 ) ''' # QOE setting if not cdn_flag: reward_frame = frame_time_len * float(BIT_RATE[bit_rate]) / 1000 - REBUF_PENALTY * rebuf - LANTENCY_PENALTY * end_delay else: reward_frame = -(REBUF_PENALTY * rebuf) if decision_flag or end_of_video: cnt+=1 # reward formate = play_time * BIT_RATE - 4.3 * rebuf - 1.2 * end_delay reward_frame += -1 * SMOOTH_PENALTY * (abs(BIT_RATE[bit_rate] - BIT_RATE[last_bit_rate]) / 1000) # last_bit_rate last_bit_rate = bit_rate # draw setting if DRAW: ax = fig.add_subplot(311) plt.ylabel("BIT_RATE") plt.ylim(300,2000) plt.plot(id_list,bit_rate_record,'-r') ax = fig.add_subplot(312) plt.ylabel("Buffer_size") plt.ylim(0,7) plt.plot(id_list,buffer_record,'-b') ax = fig.add_subplot(313) plt.ylabel("throughput") plt.ylim(0,2500) plt.plot(id_list,throughput_record,'-g') plt.draw() plt.pause(0.01) # -------------------------------------------Your Althgrithom ------------------------------------------- # which part is the althgrothm part ,the buffer based , # if the buffer is enough ,choose the high quality # if the buffer is danger, choose the low quality # if there is no rebuf ,choose the low target_buffer if 0: #50.26 if buffer_size < RESEVOIR: bit_rate = 0 elif buffer_size >= RESEVOIR + CUSHION: bit_rate = 2 elif buffer_size >= CUSHION + CUSHION: bit_rate = 3 else: bit_rate = 2 else: ''' time end_of_video cdn_newest_id download_id cdn_has_frame S_time_interval S_send_data_size S_chunk_len S_buffer_size S_rebuf S_end_delay S_play_time_len S_decision_flag S_buffer_flag S_cdn_flag ''' change=0 last = S_bitrate[0] for each in S_bitrate: if each != last: last = each change+=1 # 前一段时间gop的平均状况,用来判断处于一个相对高中低的网络,还有网络的变化幅度,再加上前短时间的状况用来预测接下来状况 sqe_fea = 9 single_fea = 5 frame_len = 10 observation_ = np.array([ S_time_interval[-frame_len:]+ S_send_data_size[-frame_len:]+ S_chunk_len[-frame_len:]+ S_buffer_size[-frame_len:]+ S_rebuf[-frame_len:]+S_end_delay[-frame_len:]+ S_play_time_len[-frame_len:]+ S_buffer_flag[-frame_len:]+ S_cdn_flag[-frame_len:]+ [time, end_of_video, cdn_newest_id - download_id, download_id, len(cdn_has_frame[0]), change]]).flatten() observation_ = preprocessing.scale(observation_) if cnt > 1: RL.store_transition(observation, action_, reward_all, observation_) reward_all_ = reward_all if RL.memory_full: RL.learn() if user_id < 1: if buffer_size < RESEVOIR: bit_rate = 0 elif buffer_size >= RESEVOIR + CUSHION: bit_rate = 2 elif buffer_size >= CUSHION + CUSHION: bit_rate = 3 else: bit_rate = 2 action_ = bit_rate else: action_ = RL.choose_action(observation_) bit_rate = action_ #bit_rate = int(action_ % len(BIT_RATE)) #target_buffer = int(action_ / len(BIT_RATE)) S_bitrate.append(bit_rate) observation = observation_ #bit_rate , target_buffer = abr.run(time,S_time_interval,S_send_data_size,S_chunk_len,S_rebuf,S_buffer_size, S_play_time_len,S_end_delay,S_decision_flag,S_buffer_flag,S_cdn_flag, end_of_video, cdn_newest_id, download_id,cdn_has_frame) # ------------------------------------------- End ------------------------------------------- if end_of_video: print("video count", video_count, reward_all) reward_all_sum += reward_all / 1000 video_count += 1 if video_count >= len(all_file_names): break cnt = 0 last_bit_rate = 0 reward_all = 0 bit_rate = 0 target_buffer = 0 S_time_interval = [0] * past_frame_num S_send_data_size = [0] * past_frame_num S_chunk_len = [0] * past_frame_num S_rebuf = [0] * past_frame_num S_buffer_size = [0] * past_frame_num S_end_delay = [0] * past_frame_num S_chunk_size = [0] * past_frame_num S_play_time_len = [0] * past_frame_num S_decision_flag = [0] * past_frame_num S_buffer_flag = [0] * past_frame_num S_cdn_flag = [0] * past_frame_num reward_all += reward_frame return reward_all_sum
def test(user_id): # path setting TRAIN_TRACES = './network_trace/' #train trace path setting, #video_size_file = './video_trace/AsianCup_China_Uzbekistan/frame_trace_' #video trace path setting, video_size_file = './video_trace/frame_trace_' #video trace path setting, LogFile_Path = "./log/" #log file trace path setting, # Debug Mode: if True, You can see the debug info in the logfile # if False, no log ,but the training speed is high DEBUG = False DRAW = False # load the trace all_cooked_time, all_cooked_bw, all_file_names = load_trace.load_trace(TRAIN_TRACES) #random_seed random_seed = 2 video_count = 0 #FPS = 25 frame_time_len = 0.04 reward_all_sum = 0 #init the environment #setting one: # 1,all_cooked_time : timestamp # 2,all_cooked_bw : throughput # 3,all_cooked_rtt : rtt # 4,agent_id : random_seed # 5,logfile_path : logfile_path # 6,VIDEO_SIZE_FILE : Video Size File Path # 7,Debug Setting : Debug net_env = env.Environment(all_cooked_time=all_cooked_time, all_cooked_bw=all_cooked_bw, random_seed=random_seed, logfile_path=LogFile_Path, VIDEO_SIZE_FILE=video_size_file, Debug = DEBUG) BIT_RATE = [500.0,1200.0] # kpbs # ABR setting CUSHION = 2 cnt = 0 # defalut setting last_bit_rate = 0 bit_rate = 0 target_buffer = 1.5 # QOE setting reward_frame = 0 reward_all = 0 SMOOTH_PENALTY= 0.02 REBUF_PENALTY = 1.5 LANTENCY_PENALTY = 0.005 call_cnt = 0 call_time = 0 switch_num = 0 S_time_interval = [] S_send_data_size = [] S_frame_type = [] S_frame_time_len = [] S_buffer_size = [] S_end_delay = [] cdn_has_frame = [] S_real_quality = [] rebuf_time = 0 buffer_flag = 0 cdn_flag=0 abr = ABR.Algorithm() abr.Initial() while True: reward_frame = 0 # input the train steps #if cnt > 1200: #plt.ioff() # break #actions bit_rate target_buffer # every steps to call the environment # time : physical time # time_interval : time duration in this step # send_data_size : download frame data size in this step # chunk_len : frame time len # rebuf : rebuf time in this step # buffer_size : current client buffer_size in this step # rtt : current buffer in this step # play_time_len : played time len in this step # end_delay : end to end latency which means the (upload end timestamp - play end timestamp) # decision_flag : Only in decision_flag is True ,you can choose the new actions, other time can't Becasuse the Gop is consist by the I frame and P frame. Only in I frame you can skip your frame # buffer_flag : If the True which means the video is rebuffing , client buffer is rebuffing, no play the video # cdn_flag : If the True cdn has no frame to get # end_of_video : If the True ,which means the video is over. time, time_interval, send_data_size, frame_time_len, rebuf, buffer_size, end_delay, cdn_newest_id, downlaod_id, cdn_has_frame, decision_flag, real_quality,buffer_flag,switch,cdn_flag, end_of_video = net_env.get_video_frame(bit_rate,target_buffer) cnt += 1 call_time += time_interval switch_num += switch S_time_interval.append(time_interval) S_buffer_size.append(buffer_size) S_send_data_size.append(send_data_size) S_frame_time_len.append(frame_time_len) S_end_delay.append(end_delay) S_real_quality.append(BIT_RATE[real_quality]) if decision_flag: S_frame_type.append(1) else: S_frame_type.append(0) rebuf_time += rebuf if not cdn_flag: reward_frame = frame_time_len * float(BIT_RATE[bit_rate]) / 1000 - REBUF_PENALTY * rebuf - LANTENCY_PENALTY * end_delay else: reward_frame = -(REBUF_PENALTY * rebuf) if call_time > 0.5 and not end_of_video: reward_frame += -(switch_num) * SMOOTH_PENALTY * (1200 - 500) / 1000 time_start = time_package.time() bit_rate , target_buffer = abr.run(S_time_interval, S_send_data_size,S_frame_time_len,S_frame_type,S_real_quality,S_buffer_size,S_end_delay,\ rebuf_time, cdn_has_frame, cdn_flag, buffer_flag) time_end = time_package.time() if time_end - time_start > 0.05: print("Warning Your decision is time out,This decision is default decision") bit_rate = 0 target_buffer = 1.5 call_time = 0 switch_num = 0 call_cnt += 1 S_time_interval= [] S_send_data_size = [] S_frame_type = [] S_frame_time_len = [] S_buffer_size = [] S_end_delay = [] S_real_quality = [] rebuf_time = 0 # --`----------------------------------------- End ------------------------------------------- reward_all += reward_frame if end_of_video: # Narrow the range of results print("video count", video_count, reward_all) reward_all_sum += reward_all / 100 video_count += 1 if video_count >= len(all_file_names): break cnt = 0 reward_all = 0 last_bit_rate = 0 bit_rate = 0 target_buffer = 1.5 S_time_interval = [] S_send_data_size = [] S_frame_type = [] S_frame_time_len = [] S_buffer_size = [] S_end_delay = [] S_real_quality = [] cdn_has_frame = [] rebuf_time = 0 buffer_flag = 0 cdn_flag=0 call_cnt = 0 call_time = 0 switch_num = 0 return reward_all_sum
def test(): TRAIN_TRACES = '/home/game/test_sim_traces/' #train trace path setting, video_size_file = '/home/game/video_size_' #video trace path setting, LogFile_Path = "/home/game/log/" #log file trace path setting, # Debug Mode: if True, You can see the debug info in the logfile # if False, no log ,but the training speed is high DEBUG = True DRAW = True # load the trace all_cooked_time, all_cooked_bw, all_cooked_rtt, _ = load_trace.load_trace( TRAIN_TRACES) #random_seed random_seed = 2 #init the environment #setting one: # 1,all_cooked_time : timestamp # 2,all_cooked_bw : throughput # 3,all_cooked_rtt : rtt # 4,agent_id : random_seed # 5,logfile_path : logfile_path # 6,VIDEO_SIZE_FILE : Video Size File Path # 7,Debug Setting : Debug net_env = env.Environment(all_cooked_time=all_cooked_time, all_cooked_bw=all_cooked_bw, all_cooked_rtt=all_cooked_rtt, random_seed=random_seed, logfile_path=LogFile_Path, VIDEO_SIZE_FILE=video_size_file, Debug=DEBUG) cnt = 0 S_time_interval = [] S_send_data_size = [] S_chunk_len = [] S_rebuf = [] S_buffer_size = [] S_end_delay = [] S_chunk_size = [] S_rtt = [] S_play_time = [] BIT_RATE = [500, 800] # kpbs TARGET_BUFFER = [2, 3] # seconds RESEVOIR = 0.5 CUSHION = 2 last_bit_rate = 0 reward_all = 0 bit_rate = 0 target_buffer = 0 # plot info idx = 0 id_list = [] bit_rate_record = [] buffer_record = [] throughput_record = [] # plot the real time image #if DRAW: # fig = plt.figure() # plt.ion() # plt.xlabel("time") # plt.axis('off') while True: # input the train steps if cnt > 500: #plt.ioff() break #actions bit_rate target_buffer # every steps to call the environment # time : physical time # time_interval : time duration in this step # send_data_size : download frame data size in this step # chunk_len : frame time len # rebuf : rebuf time in this step # buffer_size : current client buffer_size in this step # rtt : current buffer in this step # play_time_len : played time len in this step # end_delay : end to end latency which means the (upload end timestamp - play end timestamp) # decision_flag : Only in decision_flag is True ,you can choose the new actions, other time can't Becasuse the Gop is consist by the I frame and P frame. Only in I frame you can skip your frame # buffer_flag : If the True which means the video is rebuffing , client buffer is rebuffing, no play the video # cdn_flag : If the True cdn has no frame to get # end_of_video : If the True ,which means the video is over. time, time_interval, send_data_size, chunk_len, rebuf, buffer_size, rtt, play_time_len, end_delay, decision_flag, buffer_flag, cdn_flag, end_of_video = net_env.get_video_frame( bit_rate, TARGET_BUFFER[target_buffer]) cnt += 1 if time_interval != 0: # plot bit_rate id_list.append(idx) idx += time_interval bit_rate_record.append(BIT_RATE[bit_rate]) # plot buffer buffer_record.append(buffer_size) # plot throughput trace_idx = net_env.get_trace_id() throughput_record.append(all_cooked_bw[trace_idx][int(idx / 0.5)] * 1000) if decision_flag: # reward formate = play_time * BIT_RATE - 4.3 * rebuf - 1.2 * end_delay reward = sum(S_play_time) * BIT_RATE[bit_rate] - 0.8 * sum( S_rebuf) - 0.2 * (end_delay - 3) - abs(BIT_RATE[bit_rate] - BIT_RATE[last_bit_rate]) reward_all += reward # last_bit_rate last_bit_rate = bit_rate # draw setting #if DRAW: # ax = fig.add_subplot(311) # plt.ylabel("BIT_RATE") # plt.ylim(300,1000) # plt.plot(id_list,bit_rate_record,'-r') # ax = fig.add_subplot(312) # plt.ylabel("Buffer_size") # plt.ylim(0,7) # plt.plot(id_list,buffer_record,'-b') # ax = fig.add_subplot(313) # plt.ylabel("throughput") # plt.ylim(0,2500) # plt.plot(id_list,throughput_record,'-g') # plt.draw() # plt.pause(0.01) # -------------------------------------------Your Althgrithom ------------------------------------------- # which part is the althgrothm part ,the buffer based , # if the buffer is enough ,choose the high quality # if the buffer is danger, choose the low quality # if there is no rebuf ,choose the low target_buffer bit_rate, target_buffer = ABR.algorithm(time, time_interval, send_data_size, chunk_len, rebuf, buffer_size, rtt, play_time_len, end_delay, decision_flag, buffer_flag, cdn_flag, end_of_video) # ------------------------------------------- End ------------------------------------------- S_time_interval = [] S_send_data_size = [] S_chunk_len = [] S_rebuf = [] S_buffer_size = [] S_end_delay = [] S_rtt = [] S_play_time = [] S_chunk_size = [] S_time_interval.append(time_interval) S_send_data_size.append(send_data_size) S_chunk_len.append(chunk_len) S_buffer_size.append(buffer_size) S_rebuf.append(rebuf) S_end_delay.append(end_delay) S_rtt.append(rtt) S_play_time.append(play_time_len) # output #if DRAW: # plt.show() return reward_all
def train(epoch, train_trace): # path setting TRAIN_TRACES = train_trace video_size_file = './video_trace/frame_trace_' # video trace path setting, LogFile_Path = "./log/" # log file trace path setting, # load the trace all_cooked_time, all_cooked_bw, all_file_names = load_trace.load_trace( TRAIN_TRACES) # random_seed random_seed = 2 video_count = 0 frame_time_len = 0.04 reward_all_sum = 0 # init the environment net_env = env.Environment(all_cooked_time=all_cooked_time, all_cooked_bw=all_cooked_bw, random_seed=random_seed, logfile_path=LogFile_Path, VIDEO_SIZE_FILE=video_size_file, Debug=False) BIT_RATE = [500.0, 1200.0] # kpbs # ABR setting cnt = 0 # defalut setting bit_rate = 0 target_buffer = 1 # QOE setting reward_frame = 0 reward_all = 0 reward = 0 SMOOTH_PENALTY = 0.02 REBUF_PENALTY = 1.5 LANTENCY_PENALTY = 0.005 switch_num = 0 rebuf_time = 0 buffer_flag = 0 cdn_flag = 0 S_time_interval = [0] * 1000 S_send_data_size = [0] * 1000 S_frame_type = [0] * 1000 S_frame_time_len = [0] * 1000 S_buffer_size = [0] * 1000 S_end_delay = [0] * 1000 S_rebuf = [0] * 1000 S_real_quality = [0] * 1000 cdn_has_frame = [0] * 1000 flag = False n = 0 mark = 0 marks = 0 while True: if len(agent.memory) > BATCH_SIZE and cnt % 1000 == 0: agent.replay(BATCH_SIZE) reward_frame = 0 time, time_interval, send_data_size, frame_time_len, rebuf, buffer_size, end_delay, cdn_newest_id, downlaod_id, cdn_has_frame, decision_flag, real_quality, buffer_flag, switch, cdn_flag, end_of_video = net_env.get_video_frame( bit_rate, target_buffer) cnt += 1 switch_num += switch S_time_interval.append(time_interval) S_time_interval.pop(0) S_buffer_size.append(buffer_size) S_buffer_size.pop(0) S_send_data_size.append(send_data_size) S_send_data_size.pop(0) S_frame_time_len.append(frame_time_len) S_frame_time_len.pop(0) S_end_delay.append(end_delay) S_end_delay.pop(0) S_rebuf.append(rebuf) S_rebuf.pop(0) S_real_quality.append(real_quality) S_real_quality.pop(0) if decision_flag: S_frame_type.append(1) S_frame_type.pop(0) else: S_frame_type.append(0) S_frame_type.pop(0) rebuf_time += rebuf n += 1 if not cdn_flag: reward_frame = frame_time_len * float( BIT_RATE[bit_rate] ) / 1000 - REBUF_PENALTY * rebuf - LANTENCY_PENALTY * end_delay else: reward_frame = -(REBUF_PENALTY * rebuf) reward += reward_frame if decision_flag and not end_of_video: reward_frame += -(switch_num) * SMOOTH_PENALTY * (1200 - 500) / 1000 reward += reward_frame length = len(S_buffer_size) if flag: next_state = [] for i in S_buffer_size[length - history_len:]: next_state.append(i * 0.1) for i in S_send_data_size[length - history_len:]: next_state.append(i * 0.00001) for i in S_time_interval[length - history_len:]: next_state.append(i * 10) for i in S_end_delay[length - history_len:]: next_state.append(i * 0.1) # for i in S_frame_time_len[length-history_len:]: # next_state.append(i*10) for i in S_rebuf[length - history_len:]: next_state.append(i) for i in S_real_quality[length - history_len:]: next_state.append(i) marks += 1 if (n >= history_len - 10): next_state = np.reshape(next_state, [1, STATE_SIZE]) agent.remember(state, action, reward - 2, next_state, done) reward = 0 else: mark += 1 n = 0 flag = True state = [] for i in S_buffer_size[length - history_len:]: state.append(i * 0.1) for i in S_send_data_size[length - history_len:]: state.append(i * 0.00001) for i in S_time_interval[length - history_len:]: state.append(i * 10) for i in S_end_delay[length - history_len:]: state.append(i * 0.1) # for i in S_frame_time_len[length-history_len:]: # state.append(i*10) for i in S_rebuf[length - history_len:]: state.append(i) for i in S_real_quality[length - history_len:]: state.append(i) state = np.reshape(state, [1, STATE_SIZE]) action = agent.act(state) bit_rate = action[0] target_buffer = ACTION_SAPCE[action[1]] switch_num = 0 rebuf_time = 0 reward_all += reward_frame if end_of_video: agent.update_target_model() # Narrow the range of results print("video count", video_count, reward_all, mark, marks) reward_all_sum += reward_all / 100 video_count += 1 if video_count >= len(all_file_names): agent.save("save/" + str(epoch) + ".h5") break reward_all = 0 bit_rate = 0 target_buffer = 1.5 S_time_interval = [0] * 1000 S_send_data_size = [0] * 1000 S_frame_type = [0] * 1000 S_frame_time_len = [0] * 1000 S_buffer_size = [0] * 1000 S_end_delay = [0] * 1000 cdn_has_frame = [0] * 1000 rebuf_time = 0 buffer_flag = 0 cdn_flag = 0 reward = 0 flag = False n = 0 mark = 0 marks = 0 switch_num = 0 return reward_all_sum
def test(user_id): #sys.path.append('/home/team/' + user_id + '/submit/') import ABR #TRAIN_TRACES = '/home/team/network_trace/' #train trace path setting, TRAIN_TRACES = './network_trace/' #train trace path setting, #video_size_file = '/home/team/video_trace/YYF_2018_08_12/frame_trace_' #video trace path setting, video_size_file = './video_trace/Fengtimo_2018_11_3/frame_trace_' #video trace path setting, LogFile_Path = "./log/" #log file trace path setting, # Debug Mode: if True, You can see the debug info in the logfile # if False, no log ,but the training speed is high DEBUG = True DRAW = True # load the trace all_cooked_time, all_cooked_bw, _ = load_trace.load_trace(TRAIN_TRACES) #random_seed random_seed = 2 #init the environment #setting one: # 1,all_cooked_time : timestamp # 2,all_cooked_bw : throughput # 3,all_cooked_rtt : rtt # 4,agent_id : random_seed # 5,logfile_path : logfile_path # 6,VIDEO_SIZE_FILE : Video Size File Path # 7,Debug Setting : Debug net_env = env.Environment(all_cooked_time=all_cooked_time, all_cooked_bw=all_cooked_bw, random_seed=random_seed, logfile_path=LogFile_Path, VIDEO_SIZE_FILE=video_size_file, Debug=DEBUG) cnt = 0 # intial indicator # give past 5 min info # 7500 * 0.04 = 5 * 60 past_frame_num = 7500 S_time_interval = [0] * past_frame_num S_send_data_size = [0] * past_frame_num S_chunk_len = [0] * past_frame_num S_rebuf = [0] * past_frame_num S_buffer_size = [0] * past_frame_num S_end_delay = [0] * past_frame_num S_chunk_size = [0] * past_frame_num S_play_time_len = [0] * past_frame_num S_decision_flag = [0] * past_frame_num S_buffer_flag = [0] * past_frame_num S_cdn_flag = [0] * past_frame_num BIT_RATE = [500, 850, 1200, 1850] # kpbs TARGET_BUFFER = [2, 3] # seconds last_bit_rate = 0 reward_all = 0 bit_rate = 0 target_buffer = 0 # plot info idx = 0 id_list = [] bit_rate_record = [] buffer_record = [] throughput_record = [] # plot the real time image #if DRAW: # fig = plt.figure() # plt.ion() # plt.xlabel("time") # plt.axis('off') cycle_cnt = 0 while True: # input the train steps #actions bit_rate target_buffer # every steps to call the environment # time : physical time # time_interval : time duration in this step # send_data_size : download frame data size in this step # chunk_len : frame time len # rebuf : rebuf time in this step # buffer_size : current client buffer_size in this step # rtt : current buffer in this step # play_time_len : played time len in this step # end_delay : end to end latency which means the (upload end timestamp - play end timestamp) # decision_flag : Only in decision_flag is True ,you can choose the new actions, other time can't Becasuse the Gop is consist by the I frame and P frame. Only in I frame you can skip your frame # buffer_flag : If the True which means the video is rebuffing , client buffer is rebuffing, no play the video # cdn_flag : If the True cdn has no frame to get # end_of_video : If the True ,which means the video is over. time, time_interval, send_data_size, chunk_len, rebuf, buffer_size, play_time_len, end_delay, decision_flag, buffer_flag, cdn_flag, end_of_video = net_env.get_video_frame( bit_rate, target_buffer) cnt += 1 # plot bit_rate id_list.append(idx) idx += time_interval bit_rate_record.append(BIT_RATE[bit_rate]) # plot buffer buffer_record.append(buffer_size) # plot throughput trace_idx = net_env.get_trace_id() throughput_record.append( all_cooked_bw[trace_idx][int(idx / 0.5) % len(all_cooked_bw[trace_idx])] * 1000) # S_info is sequential order S_time_interval.pop(0) S_send_data_size.pop(0) S_chunk_len.pop(0) S_buffer_size.pop(0) S_rebuf.pop(0) S_end_delay.pop(0) S_play_time_len.pop(0) S_decision_flag.pop(0) S_buffer_flag.pop(0) S_cdn_flag.pop(0) S_time_interval.append(time_interval) S_send_data_size.append(send_data_size) S_chunk_len.append(chunk_len) S_buffer_size.append(buffer_size) S_rebuf.append(rebuf) S_end_delay.append(end_delay) S_play_time_len.append(play_time_len) S_decision_flag.append(decision_flag) S_buffer_flag.append(buffer_flag) S_cdn_flag.append(cdn_flag) cycle_cnt += 1 params = [] if decision_flag: # reward formate = play_time * BIT_RATE - 4.3 * rebuf - 1.2 * end_delay reward = (sum(S_play_time_len[-cycle_cnt:]) * BIT_RATE[bit_rate]) / 1000 - 0.8 * sum( S_rebuf[-cycle_cnt:]) - 0.2 * (end_delay - 3) - abs( BIT_RATE[bit_rate] - BIT_RATE[last_bit_rate]) reward_all += reward # last_bit_rate last_bit_rate = bit_rate cycle_cnt = 0 # draw setting #if DRAW: # ax = fig.add_subplot(311) # plt.ylabel("BIT_RATE") # plt.ylim(300,1000) # plt.plot(id_list,bit_rate_record,'-r') # ax = fig.add_subplot(312) # plt.ylabel("Buffer_size") # plt.ylim(0,7) # plt.plot(id_list,buffer_record,'-b') # ax = fig.add_subplot(313) # plt.ylabel("throughput") # plt.ylim(0,2500) # plt.plot(id_list,throughput_record,'-g') # plt.draw() # plt.pause(0.01) # -------------------------------------------Your Algorithm ------------------------------------------- # call your ABR bit_rate, target_buffer = ABR.algorithm( time, S_time_interval, S_send_data_size, S_chunk_len, S_rebuf, S_buffer_size, S_play_time_len, S_end_delay, S_decision_flag, S_buffer_flag, S_cdn_flag, end_of_video, params) # ------------------------------------------- End ------------------------------------------- if end_of_video: #plt.ioff() break # output #if DRAW: # plt.show() return reward_all