Ⅰ.Introduction

随着对低延迟需求的增加边缘计算或雾计算逐渐成为主流。

当前最先进的技术假设边缘服务器上的总资源利用率等于从边缘服务器提供的所有服务的资源利用率的总和。

然而边缘服务器的资源利用率与服务请求数量之间通常存在高度非线性的关系尤其CPU-GPU协同执行使资源利用率的数学建模异常复杂。

Motivation目前用于解决边缘用户分配EUA问题的算法普遍假设服务的资源利用率与边缘服务器上提供的服务数呈线性关系假设服务器的总资源利用率是每个服务请求的资源占用量的累积总和。

然而实际服务过程中资源使用量是高度动态的难以通过数学建模精确描述。

Method提出一种设备端深度强化学习DRL框架来解决边缘用户分配EUA问题基于与

MEC

Agent在服务延迟阈值约束下学习在某边缘服务器上服务的用户数量。

DRL

Agent通过同时观察系统参数直接从边缘服务器中学习非线性依赖关系。

Conclusion实验评估表明DRL框架在用户分配数量方面优于传统的确定性方法。

II.

非线性关系YOLO的执行时间与CPU和GPU参数之间的关系是非线性的。

表明执行时间不仅仅取决于单一的参数变化还受到许多隐含因素的影响例如CPU/GPU的可用性。

复杂性由于存在多个隐藏参数精确建模YOLO执行时间与系统资源之间的关系是相对困难的。

建模服务执行时间困难:

•可用处理器资源和执行时间之间的非线性关系:可用处理器资源和执行时间之间存在非线性关系内核数量少时减少内核数量对执行时间的影响更显著在高工作负载情况下增加后台工作负载会显著减慢执行速度。

跨时间的变化相同配置的同一台机器上执行时间也存在显着差异受服务调用模式和温度等多个隐藏参数影响。

Yolo

之一用户U1、U2、U4和U6请求服务s1其余用户请求服务s2每个边缘服务器由一个资源向量4

元组Available

秒用仅考虑服务单个请求的执行时间的确定性方法将U1、U2和U3分配给e1只会给s1分配2个用户每个用户3.12s给s2分配1个用户6.32s

数据驱动方法基于实际的执行时间数据和更精确的资源利用模型进行用户到服务器的分配克服确定性方法的缺点提供更有效的资源分配。

YOLO

MEC环境中每个边缘服务器的覆盖率半径为。

边缘服务器覆盖半径内的移动users

背景工作负载%、GPU

分配策略目标是在遵守服务执行的延迟阈值Γ的同时尽可能多满足服务请求。

传统的确定性方法依赖历史数据预测执行时间但由于执行时间的动态特性可能导致资源分配过度或不足。

提出的RL学习框架通过从边缘服务器的实际经验中学习服务执行模式实时优化用户-服务器绑定决策更有效地应对动态环境。

RL框架

框架中的Agent通过探索环境并从动作接收反馈来学习环境以选择更好的动作选择RL可以在不需要大量标记数据的情况下学习底层环境。

在这个

框架中Agent不断地与边缘服务器交互以采取行动执行多个服务请求并根据执行占用空间获得相应的奖励。

#compute

u2*100#查找与当前状态和动作匹配的记录fetch_state

self.df.loc[

fetch_state.empty:#找不到匹配的状态信息则返回较大的负奖励表示这是一个不利的动作选择return

-20

fetch_state.sample().iloc[0][time_yolo]

fetch_state.sample().iloc[0][time_mnet]#获取

time_yolo

spaces.Discrete(self.n_actions)

#total

spaces.Box(lownp.array([0,0,0,0,0,0]),

shape(6,

Workloadself.seed()self.current_obs

np.array(

self.df[workload_gpu].multiply(1/80).round(0).astype(int)

#round

self.df.cores.unique()self.workload_cpu

self.df.workload_cpu.unique()print(self.df)

#print

self.action_space.contains(action)

#action

State:{self.current_obs})#compute

latencydef

u2*100#查找与当前状态和动作匹配的记录fetch_state

self.df.loc[

fetch_state.empty:#找不到匹配的状态信息则返回较大的负奖励表示这是一个不利的动作选择return

-20

fetch_state.sample().iloc[0][time_yolo]

fetch_state.sample().iloc[0][time_mnet]#获取

time_yolo

get_random_state(self):#generate

state

np.random.choice(self.workload_cpu,

1)[0]#fetch

fetch_state.sample().iloc[0][workload_gpu]

#fetch

stable_baselines3.common.monitor

import

stable_baselines3.common.vec_env

import

exploration_final_eps0.07)begin

time.time()

model.learn(total_timesteps500000)

end

rl_algo():#对于每台服务器使用RL预测每个服务器的容量server_capacity

np.zeros((N,

model_rl.predict(np.array(state),

deterministicTrue)

model_exp.predict(np.array(state),

deterministicTrue)

(u1-1)*5server_capacity[server_id][0]

u1*100

outputserver_capacity[server_id][1]

u2*100

np.array([np.sum(ngb,axis1)])col2

np.array([np.arange(U)])sorted_ngb

np.concatenate((ngb,

sorted_ngb[np.argsort(sorted_ngb[:,

N])]

遍历用户根据用户连接的服务器列表和服务请求选择最大预测容量的服务器分配。

服务器有足够容量则更新服务器容量并记录分配结果for

range(U):server_list

server_list[np.argmax(server_capacity[server_list,

ser])]

server_capacity[choosen_server][ser]

#将用户分配给choosen_serverserver_capacity[choosen_server][ser]

(int(sorted_ngb[i,

{}.format(len(rl_allocation)))return

rl_allocation

使用历史服务执行数据的平均值确定边缘服务器上服务的执行时间进而确定可以分配到边缘服务器的用户数量的相应代码allocation.ipynb

def

generate_server_state(num_server)

GPU

ngb[user_ix][server_ix]1:return

1else:return

gamma[j][int(service[i])]*x[i][j]

for

latency_threshold-network_latency[j]

#alloc.write(test-model.lp)#Start

Optimizationalloc.optimize(max_seconds25)#

优化模型#ILP

Solutions:{qoe.num_solutions})ilp_allocation

(i,j)

Solutions:{qoe.num_solutions})#print(fObjective

Value:{qoe.objective_value})allocated_num_users

Allocated

{}.format(allocated_num_users))#

ilp_allocation

range(U):#获取与用户连接的服务器列表server_ngb_list

:N]

[server.iloc[i][geometry].centroid.distance(user.iloc[user_id][geometry])

for

sorted_distance_list[0].astype(int)#

分配算法lat

gamma[server_id][int(service[user_id])]#根据用户请求的服务类型和服务器获取相应的服务延迟if

latency_threshold-network_latency[server_id]:server_capacity[server_id]

lat

{}.format(len(rl_allocation)))return

rl_allocation

对于不同用户数量先拿到用户和服务器之间的邻居矩阵ngb并计算网络延迟network_latency

generate_server_state(num_server)

alloc_type

timeit.default_timer()execution_time_ilp

stop

timeit.default_timer()greedy_aloc

greedy_algo()

timeit.default_timer()execution_time_greedy

stop

timeit.default_timer()execution_time_rl

stop

execution_time_ilp,len(greedy_aloc),

execution_time_greedy,len(rl_aloc),

execution_time_rl,]

result_user.columns)result_user

epoch)result_user.to_csv(result_file,

indexFalse)

generate_server_state(num_server):#生成服务器状态计算每个服务器的

gamma

df[ram].div(1000).round(0).astype(int)

df[workload_cpu]

df[workload_cpu].div(10).round(0).astype(int)df[workload_gpu]

df[workload_gpu].multiply(1/80).round(0).astype(int)

#round

df[users_yolo].div(100).round(0).astype(int)

df[users_mnet]

df[users_mnet].div(100).round(0).astype(int)#get

unique

df.workload_cpu.unique()server_state

[]#服务器状态gamma

range(num_server):#对于每一个服务器随机选择一个

RAM、核心数和

fetch_state.sample().iloc[0][workload_gpu]

#fetch

server.iloc[n].geometry.contains(user.iloc[u].geometry):neighbourhood[u,n]1#邻居矩阵中相应位置设为

计算距离并分配延迟distance

server.iloc[n].geometry.centroid.distance(user.iloc[u].geometry)rep_lat

fetch_network_lat(int(distance),

latency_data)

rep_lat:#最大可能延迟network_latency[n]

rep_latelse:neighbourhood[u,n]0service

range(0,

1:server_service[n][int(service[u])]

1return

np.loadtxt(eua/PlanetLabData_1)[np.tril_indices(490)]ldata

ldata[

np.unique(ldata)#去重并重置数据大小使其符合150行的矩阵格式np.set_printoptions(suppressTrue)length

150latency_col

latency_col*latency_row)latency

ldata.reshape(latency_row,-1)return

latency#Fetch

np.random.choice(latency_data[distance],

size1,

replaceTrue)#根据距离从延迟数据中随机选择一个延迟值return

rep_lat/1000

load_users(num_of_users):user_raw

pd.read_csv(eua/users.csv)user_raw

user_raw.rename_axis(UID)#将数据框的索引轴重命名为

user_raw.sample(num_of_users)#随机抽样指定数量的用户数据

创建地理数据框使用Longitude和Latitude列创建点几何对象并转换坐标参考系统CRSgdf

geometry

geopandas.points_from_xy(df.Longitude,

df.Latitude),

pd.read_csv(eua/servers.csv)server_raw

server_raw.rename_axis(SID)#将数据框的索引轴重命名为

server_raw.sample(num_of_servers)

geometry

geopandas.points_from_xy(df.LONGITUDE,

df.LATITUDE),

series.geometry.buffer(radius)series[radius]

radius

InlineBackend.figure_formatretina%matplotlib

inlinecbd

figsize(15,10))ax.set_aspect(equal)ax.set_xlim(319400,

markero,

zorder1)server.centroid.plot(axax,

markers,

Melbourne(Australia))ax.legend(bbox_to_anchor(1,

0),

rl_algo_prop()和rl_algo_und()只是用了两个不同程度训练的agent模型其余部分完全一致这里只展示rl_algo_prop()。

model_und

DQN.load(trained_agents/edge_agent_under_train)

model_prop

DQN.load(trained_agents/edge_agent_proper_train)

#Load

rl_algo_prop():#...同rl_algo()#换个模型就OK

action

model_prop.predict(np.array(state),

deterministicTrue)print(Actionprop:

{}.format(action))u1

outputserver_capacity[server_id][1]

#model

model_act.predict(np.array(state),

deterministicTrue)print(Actionact:

{}.format(action))u1

outputserver_capacity[server_id][1]

#model

model_thres10.predict(np.array(state),

deterministicTrue)print(Actionthres10:

{}.format(action))u1

(u1-1)*5server_capacity[server_id][0]

u1*100

outputserver_capacity[server_id][1]

u2*100

对于训练不同回合数rl_algo_prop中动作空间的量化大小

每次agent预测出action之后从中还原出两个服务s1、s2上的服务请求数动作使用的方法不同

for

于是我暂且认为2指的是量化后的动作空间中的一个动作代表原来动作空间中的两个动作也就是第一个动作中的

u1: