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
