class Env():
def __init__(self):
self.step = 30
self.time = 0
self.edge_num = EDGE_NUM # the number of servers
self.user_num = USER_NUM # the number of users
# define environment object
self.U = []
self.fin_req_count = 0
self.prev_count = 0
self.rewards = 0
self.R = np.zeros((self.user_num))
self.O = np.zeros((self.user_num))
self.B = np.zeros((self.user_num))
self.table = BandwidthTable(self.edge_num)
self.priority = np.zeros((self.user_num, self.edge_num))
self. E = []
self.e_l = 0
self.model = 0
def get_inf(self):
# s_dim
self.reset()
s = generate_state(self.table, self.U, self.E)
s_dim = s.size
# a_dim
r_dim = len(self.U)
b_dim = len(self.U)
o_dim = self.edge_num * len(self.U)
# maximum resource
r_bound = self.E[0].capability
# maximum bandwidth
b_bound = self.table[0][1]
b_bound = b_bound.astype(np.float32)
# task size
task = TaskType()
task_inf = task.task_inf()
return s_dim, r_dim, b_dim, o_dim, r_bound, b_bound, task_inf, LIMIT, LOCATION
def reset(self):
# reset time
self.time = 0
# user
self.U = []
self.fin_req_count = 0
self.prev_count = 0
data_num = random.sample(list(range(TXT_NUM)), self.user_num)
for i in range(self.user_num):
new_user = UE(i, data_num[i])
self.U.append(new_user)
# Resource
self.R = np.zeros((self.user_num))
# Offlaoding
self.O = np.zeros((self.user_num))
# bandwidth
self.B = np.zeros((self.user_num))
# bandwidth table
self.table = BandwidthTable(self.edge_num)
# server
self.E = []
e_l = proper_edge_loc(self.edge_num)
for i in range(self.edge_num):
new_e = EdgeServer(i, e_l[i, :])
self.E.append(new_e)
"""
print("edge", new_e.edge_id, "'s loc:\n", new_e.loc)
print("========================================================")
"""
# model
self.model = priority_policy()
# initialize the request
self.priority = self.model.generate_priority(self.U, self.E, self.priority)
self.O = self.model.indicate_edge(self.O, self.U, self.priority)
for user in self.U:
user.generate_request(self.O[user.user_id])
def priority_step_forward(self):
# release the bandwidth
self.table = BandwidthTable(self.edge_num)
# release the resource
for edge in self.E:
edge.release()
# resource update
self.R = self.model.resource_update(self.R, self.E, self.U)
# offloading update
self.priority = self.model.generate_priority(self.U, self.E, self.priority)
self.O = self.model.indicate_edge(self.O, self.U, self.priority)
# bandwidth update
self.B = self.model.bandwidth_update(self.O, self.table, self.B, self.U, self.E)
# request update
for user in self.U:
# update the state of the request
user.request_update()
# it has already finished the request
if user.req.state == 4:
# rewards
self.fin_req_count += 1
user.req.state = 5 # request turn to "disconnect"
self.E[int(user.req.edge_id)].user_group.remove(user.req.user_id)
user.generate_request(self.O[user.user_id]) # offload according to the priority
# edge update
for edge in self.E:
edge.maintain_request(self.R, self.U)
self.table = edge.migration_update(self.O, self.B, self.table, self.U, self.E)
# rewards
self.rewards = self.fin_req_count - self.prev_count
self.prev_count = self.fin_req_count
# every user start to move
if self.time % self.step == 0:
for user in self.U:
user.mobility_update(self.time)
# update time
self.time += 1
return self.rewards
def text_render(self):
for user in self.U:
print("user", user.user_id, "'s loc:", user.loc)
print("request state:", user.req.state)
print("edge serve:", user.req.edge_id)
print("========================================================")
# show policy
print("priority:\n", self.priority)
print("O:", self.O)
print("R:", self.R)
print("B:", self.B)
print("========================================================")
# rewards
print("reward:", self.rewards)
print("========================================================")
# connection state:
for edge in self.E:
print("edge", edge.edge_id, "user_group:", np.sort(edge.user_group))
print("=====================update==============================")
def initial_screen_demo(self):
self.canvas = Demo(self.E, self.U, self.O, MAX_EP_STEPS)
def screen_demo(self):
self.canvas.draw(self.E, self.U, self.O)
def initial_screen_demo(self):
self.canvas = Demo(self.E, self.U, self.O, MAX_EP_STEPS)
class Env():
def __init__(self):
self.step = 30
self.time = 0
self.edge_num = EDGE_NUM # the number of servers
self.user_num = USER_NUM # the number of users
# define environment object
self.reward_all = []
self.U = []
self.fin_req_count = 0
self.prev_count = 0
self.rewards = 0
self.R = np.zeros((self.user_num))
self.O = np.zeros((self.user_num))
self.B = np.zeros((self.user_num))
self.table = BandwidthTable(self.edge_num)
self.priority = np.zeros((self.user_num, self.edge_num))
self.E = []
self.x_min, self.y_min = get_minimum()
self.e_l = 0
self.model = 0
def get_inf(self):
# s_dim
self.reset()
s = generate_state(self.table, self.U, self.E, self.x_min, self.y_min)
s_dim = s.size
# a_dim
r_dim = len(self.U)
b_dim = len(self.U)
o_dim = self.edge_num * len(self.U)
# maximum resource
r_bound = self.E[0].capability
# maximum bandwidth
b_bound = self.table[0][1]
b_bound = b_bound.astype(np.float32)
# task size
task = TaskType()
task_inf = task.task_inf()
return s_dim, r_dim, b_dim, o_dim, r_bound, b_bound, task_inf, LIMIT, LOCATION
def reset(self):
# reset time
self.time = 0
# reward
self.reward_all = []
# user
self.U = []
self.fin_req_count = 0
self.prev_count = 0
data_num = random.sample(list(range(TXT_NUM)), self.user_num)
for i in range(self.user_num):
new_user = UE(i, data_num[i])
self.U.append(new_user)
# Resource
self.R = np.zeros((self.user_num))
# Offlaoding
self.O = np.zeros((self.user_num))
# bandwidth
self.B = np.zeros((self.user_num))
# bandwidth table
self.table = BandwidthTable(self.edge_num)
# server
self.E = []
e_l = proper_edge_loc(self.edge_num)
for i in range(self.edge_num):
new_e = EdgeServer(i, e_l[i, :])
self.E.append(new_e)
"""
print("edge", new_e.edge_id, "'s loc:\n", new_e.loc)
print("========================================================")
"""
# model
self.model = priority_policy()
# initialize the request
self.priority = self.model.generate_priority(self.U, self.E,
self.priority)
self.O = self.model.indicate_edge(self.O, self.U, self.priority)
for user in self.U:
user.generate_request(self.O[user.user_id])
return generate_state(self.table, self.U, self.E, self.x_min,
self.y_min)
def priority_step_forward(self):
# record s
s = generate_state(self.table, self.U, self.E, self.x_min, self.y_min)
# release the bandwidth
self.table = BandwidthTable(self.edge_num)
# release the resource
for edge in self.E:
edge.release()
# resource update
self.R = self.model.resource_update(self.R, self.E, self.U)
# offloading update
self.priority = self.model.generate_priority(self.U, self.E,
self.priority)
self.O = self.model.indicate_edge(self.O, self.U, self.priority)
# bandwidth update
self.B = self.model.bandwidth_update(self.O, self.table, self.B,
self.U, self.E)
# request update
for user in self.U:
# update the state of the request
user.request_update()
# it has already finished the request
if user.req.state == 4:
# rewards
self.fin_req_count += 1
user.req.state = 5 # request turn to "disconnect"
self.E[int(user.req.edge_id)].user_group.remove(
user.req.user_id)
user.generate_request(
self.O[user.user_id]) # offload according to the priority
# edge update
for edge in self.E:
edge.maintain_request(self.R, self.U)
self.table = edge.migration_update(self.O, self.B, self.table,
self.U, self.E)
# rewards
self.rewards = self.fin_req_count - self.prev_count
self.prev_count = self.fin_req_count
# every user start to move
if self.time % self.step == 0:
for user in self.U:
user.mobility_update(self.time)
# update time
self.time += 1
# s, a, r, s_
return s, generate_action(self.R, self.B,
self.O), self.rewards, generate_state(
self.table, self.U, self.E, self.x_min,
self.y_min)
def ddpg_step_forward(self, a, r_dim, b_dim):
# release the bandwidth
self.table = BandwidthTable(self.edge_num)
# release the resource
for edge in self.E:
edge.release()
# update the policy every second
# resource update
self.R = a[:r_dim]
# bandwidth update
self.B = a[r_dim:r_dim + b_dim]
# offloading update
base = r_dim + b_dim
for user_id in range(self.user_num):
prob_weights = a[base:base + self.edge_num]
#print("user", user_id, ":", prob_weights)
action = np.random.choice(
range(len(prob_weights)),
p=prob_weights.ravel()) # select action w.r.t the actions prob
base += self.edge_num
self.O[user_id] = action
# request update
for user in self.U:
# update the state of the request
user.request_update()
if user.req.timer >= 5:
user.generate_request(
self.O[user.user_id]) # offload according to the priority
# it has already finished the request
if user.req.state == 4:
# rewards
self.fin_req_count += 1
user.req.state = 5 # request turn to "disconnect"
self.E[int(user.req.edge_id)].user_group.remove(
user.req.user_id)
user.generate_request(
self.O[user.user_id]) # offload according to the priority
# edge update
for edge in self.E:
edge.maintain_request(self.R, self.U)
self.table = edge.migration_update(self.O, self.B, self.table,
self.U, self.E)
# rewards
self.rewards = self.fin_req_count - self.prev_count
self.prev_count = self.fin_req_count
# every user start to move
if self.time % self.step == 0:
for user in self.U:
user.mobility_update(self.time)
# update time
self.time += 1
# return s_, r
return generate_state(self.table, self.U, self.E, self.x_min,
self.y_min), self.rewards
def text_render(self):
print("R:", self.R)
print("B:", self.B)
"""
base = USER_NUM +USER_NUM
for user in range(len(self.U)):
print("user", user, " offload probabilty:", a[base:base + self.edge_num])
base += self.edge_num
"""
print("O:", self.O)
for user in self.U:
print("user", user.user_id, "'s loc:\n", user.loc)
print("request state:", user.req.state)
print("edge serve:", user.req.edge_id)
for edge in self.E:
print("edge", edge.edge_id, "user_group:", edge.user_group)
print("reward:", self.rewards)
print("=====================update==============================")
def initial_screen_demo(self):
self.canvas = Demo(self.E, self.U, self.O, MAX_EP_STEPS)
def screen_demo(self):
self.canvas.draw(self.E, self.U, self.O)