Deep Reinforcement Learning for Task Offloading in Mobile Edge Computing Systems

移动边缘计算系统中任务卸载的深度强化学习

时间：2020
期刊：TMC

都卸载到边缘节点-负载过大-处理延迟更大-延迟可能超过截止日期未被处理而被遗弃
负载不确定-在MD还是边缘服务器卸载到边缘节点哪个服务器卸载涉及卸载决策

在移动边缘计算系统中，当大量移动设备将其任务卸载到边缘节点时，边缘节点可能具有高负载。那些被卸载的任务可能会经历巨大的处理延迟，甚至在截止日期到期时被丢弃。
由于边缘节点的负载动态不确定，每个设备都很难以分散的方式确定其卸载决策（即是否卸载，以及应将任务卸载到哪个边缘节点）。

在这项工作中，我们考虑不可分和延迟敏感的任务以及边缘负荷动态，并制定任务卸载问题，以尽量减少预期的长期成本。我们提出了一种基于无模型深度强化学习的分布式算法，每个设备都可以在不知道其他设备的任务模型和卸载决策的情况下确定其卸载决策。为了改进算法中长期代价的估计，我们结合了长短时记忆（LSTM）、决斗深度网络和双DQN技术。仿真结果表明，与现有的几种算法相比，本文提出的算法能够更好地利用边缘节点的处理能力，显著降低任务丢弃率和平均延迟。

1.介绍

1.1背景和动机

（引入边缘计算） 如今，移动设备负责处理许多计算密集型任务，如数据处理和人工智能。尽管移动设备不断发展，但由于计算资源有限，这些设备可能无法以低延迟本地处理所有任务。为了促进高效的任务处理，引入了移动边缘计算（MEC）[1]，也称为雾计算[2]和多址边缘计算[3]。MEC便于移动设备将其计算任务卸载到附近的边缘节点进行处理，以减少任务处理延迟。对于那些对延迟敏感的任务，它还可以降低丢弃任务的比率（延时小，减少到ddl被丢弃）。
（问题，怎么分） 在MEC中，有两个主要问题与任务卸载有关。第一个问题是移动设备是否应该将其任务转移到边缘节点。第二个问题是，如果移动设备决定执行卸载，那么该设备应该将其任务卸载到哪个边缘节点。为了解决这些问题，一些现有的工作提出了任务卸载算法。
Wang等人在[4]中，提出了一种算法来确定卸载决策，以使网络收益最大化。Biet al.in[5]考虑了无线供电的MEC场景，并提出了一种算法来优化卸载和功率转移决策。在文献[4]、[5]中，从边缘节点获得的每个设备的处理能力与卸载到边缘节点的任务数量无关。（没考虑边缘节点的处理能力）
（集中式）然而，在实践中，边缘节点的处理能力可能有限，因此边缘节点分配给移动设备的处理能力取决于边缘节点的负载水平（即卸载到边缘节点的并发任务数量）。当大量移动设备将其任务卸载到同一边缘节点时，该边缘节点的负载可能会很高，因此那些卸载的任务可能会经历较大的处理延迟。有些任务甚至可能在截止日期到期时被放弃。一些现有的工作已经解决了边缘节点的负载水平，并提出了集中式任务卸载算法。Eshraghiet al.in[6]提出了一种算法，考虑到移动设备的特定计算需求，该算法优化了移动设备的卸载决策。Lyuet等人[7]针对延迟敏感任务，提出了一种算法，以最小化任务截止时间约束下的任务卸载能耗。在[8]中，Chen等人为软件定义的超密集网络设计了一种集中式算法，以最小化任务延迟。在[9]中，Poularakiset等人研究了任务卸载和路由的联合优化。然而，[6]–[9]中这些集中算法的操作可能需要系统的完整信息。
（分布式–和其他设备有关，）其他工作提出了考虑边缘节点负载水平的分布式任务卸载算法，每个移动设备以分散的方式做出卸载决策。设计这样一种分布式算法很有挑战性。这是因为，当设备做出卸载决策时，设备不知道边缘节点的首要负载级别（优先级），因为负载还取决于其他移动设备的卸载决策。此外，边缘节点处的负载水平可能会随时间而变化。为了应对这些挑战，Lyuet等人在[10]中重点研究了可分割任务，并提出了一种基于Lyapunov的算法来确保任务队列的稳定性。在[11]中，Liet al.考虑了移动设备之间的战略卸载交互，并提出了一种基于价格的分布式算法。Shah Mansouri等人在[12]中设计了一种潜在的基于游戏的加载算法，以最大限度地提高每台设备的体验质量。JoSilo等人在[13]中设计了一种基于Stackelberg游戏的分布式算法。Yanget al.在[14]中提出了一种分布式卸载算法，以解决移动设备之间的无线信道竞争。Netoet al.in[15]提出了一种基于估计的方法，每个设备根据估计的处理和传输容量做出卸载决策。Leet al.in[16]提出了一种基于在线优化技术的算法，以最小化任务的最大延迟。
在这项工作中，我们重点研究了MEC系统中的任务卸载问题，并提出了一种分布式算法来解决边节点上未知的负载水平动态问题。
与上述作品[10]-[16]相比，我们考虑了一个不同且更现实的MEC方案。首先，现有工作[10]被认为是可分割的任务（即任务可以任意分割），这可能是不现实的，因为任务中的位之间存在依赖关系。虽然作品[11] -[15]考虑不可分割的任务，但他们不考虑底层排队系统(排队延迟)。因此，每个任务的处理和传输都应该在一个时间段内完成（或在下一个任务到达之前），这在实践中可能并不总是得到保证。与那些文献[10]–[15]不同的是，我们将不可分割的任务与排队系统一起考虑，并考虑了一个任务的处理和传输可以在多个时隙内继续的实际情况。这种情况很难处理，因为当一个新任务到达时，它的延迟可能会受到在前一个时隙中到达的其他设备的任务的决定的影响。其次，与相关研究[10]–[16]考虑的延迟容忍任务不同，我们关注的是具有处理期限的延迟敏感任务。这对解决这一问题具有挑战性，因为截止日期可能会影响边缘节点的负载水平，从而影响卸载任务的延迟。
在上述MEC系统下，由于任务之间的复杂交互，很难应用博弈论和在线优化等传统方法。为了应对这些挑战，在这项工作中，我们建议使用深度Q学习[17]，这是一种无模型的深度强化学习（DRL）技术。这种方法使代理能够在不了解系统建模和动力学的情况下，基于局部观测做出决策。一些现有的工作，如[18]–[20]已经为MEC系统提出了基于DRL的算法，而他们的重点是集中卸载算法。Zhao等人在[21]中提出了一种基于DRL的分布式卸载算法，该算法解决了移动设备之间的无线信道竞争，而每个移动设备上的算法都需要其他移动设备的服务质量信息。与那些文献[18]–[21]不同，我们的目标是提出一种基于DRL的分布式算法，解决边缘节点未知的负载动态问题。它使每个移动设备能够在不知道其他移动设备的信息（例如，任务模型、卸载决策）的情况下做出卸载决策。

1.2解决方法和贡献

（分布式多任务不可分割一个任务在多个时隙中进行有截止日期其他设备负载未知）
在这项工作中，我们考虑了边缘节点的未知负载水平动态，并提出了一种基于DRL的算法MEC系统的分布式卸载算法。在该算法中，每个移动设备都可以使用本地观察到的信息（包括任务大小、队列信息和边缘节点的历史负载水平）以分散的方式确定卸载决策。主要贡献如下

MEC系统的任务卸载问题：我们为不可分割和延迟敏感的任务模拟了一个任务卸载问题。该问题考虑了边缘节点的负载水平动态，旨在最小化任务的预期长期成本（考虑到任务的延迟和被丢弃任务的惩罚）。
基于DRL的任务卸载算法：为了实现预期的长期成本最小化，我们提出了一种基于无模型DRL的分布式卸载算法，使每个移动设备能够在不知道其他移动设备的任务模型和卸载决策的情况下做出卸载决策。为了改进算法中预期长期代价的估计，我们引入了长短时记忆（LSTM）、决斗深度Q网络（DQN）和双DQN技术。
性能评估：我们进行了仿真，结果表明，与[14]中潜在的基于游戏的卸载算法(PGOA)和[15]中的用户级在线卸载框架(ULOF)相比，我们提出的算法能够更好地利用移动设备和边缘节点的处理能力，它可以显著降低任务延迟率和平均延迟。
本文的其余部分组织如下。第2节介绍了系统模型，第3节给出了问题公式。我们在第4节介绍了基于DRL的算法，并在第5节评估了其性能。结论见第6节。对于表示法，我们使用 Z + + \Bbb{Z}_{++} Z++来表示正整数集。

2.系统模型

在MEC系统中，我们考虑了一组边缘节点 N = { 1 , 2 , 3... N } \mathcal{N}=\{1,2,3...N\} N={1,2,3...N}和一组移动设备 M = { 1 , 2 , . . . M } \mathcal{M}=\{1,2,...M\} M={1,2,...M}。我们关注一个包含一组时隙 T = { 1 , . . T } \mathcal{T}=\{1,..T\} T={1,..T}的片段，其中每个时隙的持续时间为 Δ \Delta Δ几秒钟。在下文中，我们展示了移动设备和边缘节点模型，图1给出了一个示例。

2.1移动设备模型

我们关注移动设备的计算任务，其中每个任务都是不可分割的，因此可以在本地处理，也可以卸载到边缘节点进行处理。我们假设在每个时间段的开始，移动设备都有一个新任务以一定的概率到达。当移动设备有新任务到达时，它首先需要决定是在本地处理任务，还是将任务卸载到边缘节点。如果移动设备决定在本地处理任务，那么它的调度器（见图1）将把任务放入计算队列进行处理。否则，移动设备需要决定将任务卸载到哪个边缘节点。然后，调度器将任务放入传输队列进行卸载。然后，卸载的任务将通过无线链路发送到选定的边缘节点。对于计算（或传输）队列，我们假设如果一个任务的处理（或传输）在一个时隙中完成，那么队列中的下一个任务将在下一个时隙的开始处被处理（或传输）。

2.1.1任务模型

在时间开始 t ∈ T t\mathcal{\in T} t∈T时、如果移动设备 m ∈ M m\mathcal{\in M} m∈M有一个新到达的任务，我们定义了一个变量 k m ( t ) ∈ Z + + k_m(t)\in{\Bbb{Z}_{++}} km(t)∈Z++来表示任务的唯一索引。如果移动设备在时隙开始时没有新的任务到达，那么为了简化表示， k m ( t ) k_m(t) km(t)被设置为零。
设 λ m ( t ) \lambda_m(t) λm(t)（以位为单位）表示时隙 t ∈ T t\mathcal{\in T} t∈T开始时新到达任务的位数。如果在时隙 t t t 开始时存在新任务 k m ( t ) k_m(t) km(t)，则 λ m ( t ) \lambda_m(t) λm(t)等于任务 k m ( t ) k_m(t) km(t)的大小。否则， λ m ( t ) \lambda_m(t) λm(t)被设置为零。我们将任务 k m ( t ) k_m(t) km(t)的大小设置为一个离散集 Λ = { λ 1 , λ 2 , . . . λ ∣ Λ ∣ } \Lambda=\{\lambda_1,\lambda_2,...\lambda_{|\Lambda|}\} Λ={λ1,λ2,...λ∣Λ∣}和 ∣ Λ ∣ |\Lambda| ∣Λ∣的可用值。因此， λ m ( t ) ∈ Λ ⋃ { 0 } \lambda_m(t){\in{\Lambda} \bigcup\{0\}} λm(t)∈Λ⋃{0}。此外，任务 k m ( t ) k_m(t) km(t)要求处理密度为 ρ m \rho_m ρm（单位为每比特的CPU周期），即处理一个数据单元所需的CPU周期数。任务 k m ( t ) k_m(t) km(t)有一个截止时间 τ m \tau_m τm（在时隙中）。也就是说，如果任务 k m ( t ) k_m(t) km(t)在时隙 t + τ m − 1 t+\tau_m-1 t+τm−1结束时尚未完全处理，那么它将立即被丢弃。

2.1.2任务卸载决策

如果移动设备 m ∈ M m\mathcal{\in M} m∈M在时隙 t ∈ T t\mathcal{\in T} t∈T的开头有一个新到达的任务 k m ( t ) k_m(t) km(t)，然后，它需要对任务 k m ( t ) k_m(t) km(t)做出如下卸载决策。
首先，让二进制变量 x m ( t ) ∈ { 0 , 1 } x_m(t)\in\{0,1\} xm(t)∈{0,1}任务 k m ( t ) k_m(t) km(t)是本地处理还是卸载到边缘节点。如果任务要在本地处理（或卸载到边缘节点），我们将 x m ( t ) = 1 x_m(t)=1 xm(t)=1（或0）。在时隙 t t t的开始， λ m ( t ) x m ( t ) \lambda_m(t)x_m(t) λm(t)xm(t)是到达移动设备 m m m的计算队列的比特数， λ m ( t ) ( 1 − x m ( t ) ) \lambda_m(t)(1-x_m(t)) λm(t)(1−xm(t))是到达移动设备传输队列的比特数。(=1在本地，=0在边缘节点)
其次，如果任务 k m ( t ) k_m(t) km(t)要卸载到边缘节点，那么让二进制变量 y m , n ( t ) ∈ { 0 , 1 } y_{m,n}(t)\in\{0,1\} ym,n(t)∈{0,1}表示任务 k m ( t ) k_m(t) km(t)是否卸载到边缘节点 n n n。如果任务 k m ( t ) k_m(t) km(t)被卸载到边缘节点 n n n，我们设置 y m , n ( t ) = 1 y_{m,n}(t)=1 ym,n(t)=1，否则 y m , n ( t ) = 0 y_{m,n}(t)=0 ym,n(t)=0。设置 y m ( t ) = ( y m , n ( t ) , n ∈ N ) y_m(t)=(y_{m,n}(t),n\mathcal{\in N}) ym(t)=(ym,n(t),n∈N)。请注意，每个任务只可以卸载到一个边缘节点，即：
如果 z ∈ Z z\mathcal{\in Z} z∈Z，则指示符号 I ( z ∈ Z ) = 1 \Bbb{I}(z\mathcal{\in Z})=1 I(z∈Z)=1否则等于零。(X=0到边缘节点处理是前提而不是在移动设备上处理，y=1卸载了)

2.1.3计算队列（本地）

计算队列以先进先出（FIFO）方式运行。到达的是要在本地处理的任务。我们考虑在计算队列中处理任务的一个CPU。设 f m d e v i c e f_m^{device} fmdevice（以每秒CPU周期为单位）表示移动设备 m ∈ M m\mathcal{\in M} m∈M的CPU处理能力。 f m d e v i c e f_m^{device} fmdevice的值是一个常数。在时隙 t ∈ T t\mathcal{\in T} t∈T的开始，如果任务 k m ( t ) k_m(t) km(t)被放置在计算队列中，那么我们定义 l m c o m p ( t ) ∈ T l_m^{comp}(t)\mathcal{\in T} lmcomp(t)∈T来表示任务 k m ( t ) k_m(t) km(t)被处理或丢弃的时隙。在不丧失一般性的情况下，如果任务 k m ( t ) k_m(t) km(t)未放入计算队列或 k m ( t ) = 0 k_m(t)=0 km(t)=0，则我们将 l m c o m p ( t ) = 0 l_m^{comp}(t)=0 lmcomp(t)=0。
让 δ m c o m p ( t ) \delta _m^{comp}(t) δmcomp(t)（在时隙中）表示如果任务 k m ( t ) k_m(t) km(t)被放入计算队列，它将等待处理的时隙数。请注意，移动设备 m m m将在决定放置任务的队列之前计算 δ m c o m p ( t ) \delta _m^{comp}(t) δmcomp(t)的值。在 t ′ < t t'<t t′<t时给定 l m c o m p ( t ) l_m^{comp}(t) lmcomp(t)， δ m c o m p ( t ) \delta _m^{comp}(t) δmcomp(t)的值计算如下。对于 m ∈ M m\mathcal{\in M} m∈M和 t ∈ T t\mathcal{\in T} t∈T，

其中运算符 [ z ] + = m a x { 0 , z } [z]^+=max\{0,z\} [z]+=max{0,z}，我们设置 l m c o m p ( 0 ) = 0 l_m^{comp}(0)=0 lmcomp(0)=0。具体来说， m a x t ′ ∈ { 0 , 1 , . . . t − 1 } l m c o m p ( t ′ ) max_{t'\in \{0,1,...t-1\}}l_m^{comp}(t') maxt′∈{0,1,...t−1}lmcomp(t′)确定在时隙 t t t之前放入计算队列的所有任务被处理或丢弃时的时隙。因此， δ m c o m p ( t ) \delta _m^{comp}(t) δmcomp(t)确定任务 k m ( t ) k_m(t) km(t)应等待处理的时隙数。
例如，假设任务 k m ( 1 ) k_m(1) km(1)被放置在计算队列中，其处理将在时间间隔5内完成，即 l m c o m p ( 1 ) = 5 l_m^{comp}(1)=5 lmcomp(1)=5。同时，假设 k m ( 2 ) = 0 k_m(2)=0 km(2)=0，即 l m c o m p ( 2 ) = 0 l_m^{comp}(2)=0 lmcomp(2)=0。在时隙3的开始，如果任务 k m ( 3 ) k_m(3) km(3)被放入计算队列中，则其处理将在时隙 l m c o m p ( 1 ) = 5 l_m^{comp}(1)=5 lmcomp(1)=5之后开始。因此，它应该等待 δ m c o m p ( 3 ) = [ m a x { 5 , 0 } − 3 + 1 ] + = 3 \delta _m^{comp}(3)=[max\{5,0\}-3+1]^+=3 δmcomp(3)=[max{5,0}−3+1]+=3个时隙。

如果移动设备 m ∈ M m\mathcal{\in M} m∈M将任务 k m ( t ) k_m(t) km(t)放置在时隙 t ∈ T t\mathcal{\in T} t∈T开头的计算队列（即 x m ( t ) = 1 x_m(t)=1 xm(t)=1），则任务 k m ( t ) k_m(t) km(t)将在时隙 l m c o m p ( t ) l_m^{comp}(t) lmcomp(t)中被处理或丢弃：其中⌈·⌉是上限函数。（向上取整）具体而言，任务 k m ( t ) k_m(t) km(t)的处理将在时隙 δ m c o m p ( t ) \delta _m^{comp}(t) δmcomp(t)的开始处开始。处理任务所需的时间段数为 ⌈ λ m ( t ) f m d e v i c e Δ / ρ m ⌉ ⌈\frac {\lambda_m(t)}{f_m^{device}\Delta /\rho_m}⌉ ⌈fmdeviceΔ/ρmλm(t)⌉（总时间除以间隔等于段数 lamda 位为单位 f是每秒处理CPU周期 rho每位处理CPU周期数）。因此，运算器中的第一项是在不考虑任务截止日期的情况下完成任务 k m ( t ) k_m(t) km(t)处理的时间段。第二项是任务 k m ( t ) k_m(t) km(t)将被丢弃的时间段。因此， l m c o m p ( t ) l_m^{comp}(t) lmcomp(t)确定任务 k m ( t ) k_m(t) km(t)将将被处理或丢弃的时间段。

2.1.4传输队列

传输队列以FIFO方式运行。到达的是要卸载到边缘节点的任务。移动设备上的无线网络链路接口将传输队列中的任务发送到所选边缘节点。无线网络模型和从移动设备到边缘节点的传输速率如下所示。我们考虑了一个无线网络模型，其中移动设备传输正交信道。从移动设备到边缘节点的无线传输遭受路径损耗和小范围衰落[11]，[23]。设 ∣ h m , n ∣ 2 |h_{m,n}|^2 ∣hm,n∣2表示来自移动设备 m ∈ M m\mathcal{\in M} m∈M到边节点 n ∈ N n\mathcal{\in N} n∈N的信道增益。让 P P P表示移动设备的传输功率。从移动设备 m m m到边缘节点 n n n的传输速率由 r m , n t r a n r_{m,n}^{tran} rm,ntran（以比特/秒为单位） 表示，计算如下:
(信道增益✖️传输功率等于信号接收功率分母是噪声功率 W带宽信道容量就是无干扰最大传输速率)

其中， W W W表示分配给信道的带宽， σ 2 \sigma^2 σ2表示在边缘节点处接收到的噪声功率。 r m , n t r a n r_{m,n}^{tran} rm,ntran的值被假定为一个常数。
在时隙 t ∈ T t\mathcal{\in T} t∈T的开头，如果任务 k m ( t ) k_m(t) km(t)被放置在传输队列中进行卸载，那么我们定义一个变量 l m t r a n ∈ T l_{m}^{tran}\mathcal{\in T} lmtran∈T表示任务 k m ( t ) k_m(t) km(t)被发送或丢弃的时隙。在不丧失一般性的情况下，如果任务 k m ( t ) k_m(t) km(t)未放入传输队列或 k m ( t ) = 0 k_m(t)=0 km(t)=0，则我们将 l m t r a n ( t ) = 0 l_m^{tran}(t)=0 lmtran(t)=0。让 δ m t r a n ( t ) \delta _m^{tran}(t) δmtran(t)（在时隙中）表示如果任务 k m ( t ) k_m(t) km(t)被放入传输队列，它将等待处理的时隙数。请注意，移动设备 m m m将在决定放置任务的队列之前计算 δ m t r a n ( t ) \delta _m^{tran}(t) δmtran(t)的值。在 t ′ < t t'<t t′<t时给定 l m t r a n ( t ) l_m^{tran}(t) lmtran(t)， δ m t r a n ( t ) \delta _m^{tran}(t) δmtran(t)的值计算如下。对于 m ∈ M m\mathcal{\in M} m∈M和 t ∈ T t\mathcal{\in T} t∈T，

其中我们设置 l m t r a n ( 0 ) = 0 l_m^{tran}(0)=0 lmtran(0)=0以简化表示。

在时隙 t ∈ T t\mathcal{\in T} t∈T，如果设备 m ∈ M m\mathcal{\in M} m∈M在传输队列中标记任务 k m ( t ) k_m(t) km(t)（即 x m ( t ) = 0 x_m(t)=0 xm(t)=0，卸载到边缘节点），则任务 k m ( t ) k_m(t) km(t)将在时隙 l m t r a n ( t ) l_m^{tran}(t) lmtran(t)中被发送或丢弃：

（一个是计算队列一个是传输队列）

2.2边缘节点模型

每个边缘节点 n ∈ N n\mathcal{\in N} n∈N维护 M M M个队列，每个队列对应于集合 M \mathcal M M中的一个移动设备。我们假设在一个时隙中的边缘节点接收到一个卸载的任务后，该任务将在下一个时隙开始时被放置在边缘节点的相应队列中。
如果在时隙 t ∈ T t\mathcal{\in T} t∈T的开始移动设备 m ∈ M m\mathcal{\in M} m∈M的任务被放置在边缘节点 n ∈ N n\mathcal{\in N} n∈N的队列中，我们定义一个变量 k m , n e d g e ( t ) ∈ Z + + k_{m,n}^{edge}(t)\in{\Bbb{Z}_{++}} km,nedge(t)∈Z++来表示任务的唯一索引。具体来说，如果任务 k m ( t ′ ) , t ′ ∈ { 1 , 2 , . . . t − 1 } k_m(t'),t'{\in \{1,2,...t-1\}} km(t′),t′∈{1,2,...t−1}在时隙 t − 1 t-1 t−1时发送到边缘节点 n n n，那么 k m , n e d g e ( t ) = k m ( t ′ ) k_{m,n}^{edge}(t)=k_m(t') km,nedge(t)=km(t′)。请注意，如果不存在这样的任务，那么我们设置 k m , n e d g e ( t ) = 0 k_{m,n}^{edge}(t)=0 km,nedge(t)=0。让 λ m , n e d g e ( t ) ∈ Λ ⋃ { 0 } \lambda_{m,n}^{edge}(t){\in{\Lambda} \bigcup\{0\}} λm,nedge(t)∈Λ⋃{0}（以位为单位）表示在时隙 t t t开始时到达边缘节点 n n n处的移动设备 m m m队列中的位数。如果任务 k m , n e d g e ( t ) k_{m,n}^{edge}(t) km,nedge(t)在时隙 t t t开始时被放置在相应的队列中，则 λ m , n e d g e ( t ) \lambda_{m,n}^{edge}(t) λm,nedge(t)等于任务 k m , n e d g e ( t ) k_{m,n}^{edge}(t) km,nedge(t)的大小。否则， λ m , n e d g e ( t ) = 0 \lambda_{m,n}^{edge}(t)=0 λm,nedge(t)=0。
在下面，我们首先描述队列。然后，我们减少任务处理或丢弃时间。

2.2.1边缘节点排队

与边缘节点移动设备相关联的队列以FIFO方式运行。队列的到达是移动设备卸载到该边缘节点的任务。让 q m , n e d g e ( t ) q_{m,n}^{edge}(t) qm,nedge(t)（以位为单位）表示在时隙 t ∈ T t\mathcal{\in T} t∈T结束时边缘节点 n ∈ N n\mathcal{\in N} n∈N上移动设备 m ∈ M m\mathcal{\in M} m∈M队列的长度。在这些在边缘节点 n n n的队列中，如果在时隙 t t t中有移动设备 m m m的任务到达队列（即 λ m , n e d g e ( t ) > 0 \lambda_{m,n}^{edge}(t)>0 λm,nedge(t)>0）(lamda时间t开始时的新到达队列)，或者在时隙 t − 1 t-1 t−1末端的队列非空（即 q m , n e d g e ( t − 1 ) > 0 q_{m,n}^{edge}(t-1)>0 qm,nedge(t−1)>0）（上个时隙有剩余队列），则我们将移动设备 m m m的队列称为时隙 t t t中的活动队列(???)。设 B n ( t ) \mathcal B_n(t) Bn(t)表示时隙 t t t中边缘节点 n n n处的活动队列集。也就是说，对于 n ∈ N n\mathcal{\in N} n∈N和 t ∈ T t\mathcal{\in T} t∈T，

用 B n ( t ) \mathcal B_n(t) Bn(t)表示在时隙 t t t中边缘节点 n n n处活动队列的数量，即 B n ( t ) = ∣ B n ( t ) ∣ \mathcal B_n(t)=|\mathcal B_n(t)| Bn(t)=∣Bn(t)∣。(活动队列集等于活动队列数量用集合表示数量)

我们考虑的情况下，移动设备的任务具有相同的优先级。(这项工作可以扩展到不同移动设备的任务具有不同优先级的场景。这可以通过为不同移动设备的队列设置不同的权重，并根据权重分配处理能力来实现。)每个边缘节点都有一个CPU，用于处理队列中的任务。在每个时隙 t ∈ T t\mathcal{\in T} t∈T中，边缘节点 n ∈ N n\mathcal{\in N} n∈N处的活动队列（即集合 B n ( t ) \mathcal B_n(t) Bn(t)中的队列）平均共享边缘节点 n n n处CPU的处理能力。这是具有相同处理能力共享的广义处理器共享（GPS）模型[24]。请注意，由于活动队列 B n ( t ) \mathcal B_n(t) Bn(t)的数量是时变的，并且是先验未知的，因此分配给每个队列的处理能力可以随时间而变化。同时，移动设备和边缘节点可能事先不具有该分配的处理能力的信息。
设 f m e d g e f_m^{edge} fmedge（以每秒CPU周期为单位）表示边缘节点 n n n的处理能力。我们假设对于 n ∈ N n\mathcal{\in N} n∈N移动设备知道 f m e d g e f_m^{edge} fmedge的值。设 e m , n e d g e ( t ) e_{m,n}^{edge}(t) em,nedge(t)（以位为单位）表示在时隙 t ∈ T t\mathcal{\in T} t∈T结束时队列丢弃的任务的位数。因此，队列长度更新如下。对于 m ∈ M m\mathcal{\in M} m∈M， n ∈ N n\mathcal{\in N} n∈N和 t ∈ T t\mathcal{\in T} t∈T，

(t结束时剩的队列长度=上一个时隙剩的队列长度+这个时隙开始时剩的队列长度—本时隙处理的长度+本时隙结束时丢弃的队列长度)

2.2.2任务处理或丢弃

如果在时隙 t ∈ T t\mathcal{\in T} t∈T开始时，任务 k m , n e d g e ( t ) k_{m,n}^{edge}(t) km,nedge(t)被放置在边缘节点 n ∈ N n\mathcal{\in N} n∈N移动设备 m ∈ M m\mathcal{\in M} m∈M的相应队列中，那么我们定义一个变量 l m , n e d g e ( t ) ∈ T l_{m,n}^{edge}(t)\mathcal{\in T} lm,nedge(t)∈T来表示该任务被边缘节点 n n n处理或丢弃时的时隙。由于边缘节点 n n n处的未来负载不确定，移动设备 m m m和边缘节点 n n n在相关任务 k m , n e d g e ( t ) k_{m,n}^{edge}(t) km,nedge(t)被处理或丢弃之前不知道 l m , n e d g e ( t ) l_{m,n}^{edge}(t) lm,nedge(t)的值。在不丧失一般性的情况下，如果 k m , n e d g e ( t ) = 0 k_{m,n}^{edge}(t)=0 km,nedge(t)=0，设置 l m , n e d g e ( t ) = 0 l_{m,n}^{edge}(t)=0 lm,nedge(t)=0。
对于变量 l m , n e d g e ( t ) l_{m,n}^{edge}(t) lm,nedge(t)的定义，让 l ^ m , n e d g e ( t ) \hat{l}_{m,n}^{edge}(t) l^m,nedge(t)表示任务 k m , n e d g e ( t ) k_{m,n}^{edge}(t) km,nedge(t)开始处理时的时隙，即对于 m ∈ M m\mathcal{\in M} m∈M， n ∈ N n\mathcal{\in N} n∈N和 t ∈ T t\mathcal{\in T} t∈T，

我们在这里设置 l m , n e d g e ( 0 ) = 0 l_{m,n}^{edge}(0)=0 lm,nedge(0)=0。具体来说，任务 k m , n e d g e ( t ) k_{m,n}^{edge}(t) km,nedge(t)开始处理时的时隙不早于任务到达队列时的时隙或者早到的每个任务都已被处理或丢弃时的时隙。

考虑到负载级别的实现， l m , n e d g e ( t ) l_{m,n}^{edge}(t) lm,nedge(t)满足以下约束。对于 m ∈ M m\mathcal{\in M} m∈M， n ∈ N n\mathcal{\in N} n∈N和 t ∈ T t\mathcal{\in T} t∈T，

任务 k m , n e d g e ( t ) k_{m,n}^{edge}(t) km,nedge(t)的大小不大于边缘节点 n n n从时隙 l ^ m , n e d g e ( t ) \hat{l}_{m,n}^{edge}(t) l^m,nedge(t)到 l m , n e d g e ( t ) l_{m,n}^{edge}(t) lm,nedge(t)分配给移动设备 m m m的总处理能力，并且大于从时隙 l ^ m , n e d g e ( t ) \hat{l}_{m,n}^{edge}(t) l^m,nedge(t)到 l m , n e d g e ( t ) − 1 l_{m,n}^{edge}(t)-1 lm,nedge(t)−1的总处理能力。
(10)这段时隙内的处理能力大于任务位数
(11)小于任务位数否则就在t-1时隙内完成处理或被遗弃

3.任务卸载问题

在每个时隙开始时，每个移动设备都会观察其状态（例如，任务大小、队列信息）。如果要处理新任务，则移动设备会为该任务选择一个动作。该状态和操作将为移动设备带来成本（即如果任务被处理带来的延迟或者如果任务被丢弃受到的惩罚）。每个设备的目标都是通过优化从状态到动作的策略映射，将其预期的长期成本降至最低。

3.1状态

让矩阵 H ( t ) \boldsymbol H(t) H(t)表示前 T s t e p T^{step} Tstep（从时隙 t − T s t e p t-T^{step} t−Tstep到时间 t − 1 t-1 t−1) 个时隙内每个边缘节点的负载水平的历史（即活动队列的数量）。它是一个 T s t e p × N T^{step}\times N Tstep×N的矩阵。设 { H ( t ) } i ， j \{\boldsymbol H(t)\}_{i，j} {H(t)}i，j表示 H ( t ) \boldsymbol H(t) H(t)的 ( i , j ) (i,j) (i,j)元素，它对应于从时隙 t − T s t e p t-T^{step} t−Tstep开始的第 i i i个时隙中(即时隙 t − T s t e p + i − 1 t-T^{step}+i-1 t−Tstep+i−1)边缘节点 j j j的负载水平。即，

B n ( t ) \mathcal B_n(t) Bn(t)表示时隙 t t t中边缘节点 n n n处的活动队列集

为了得到 H ( t ) \boldsymbol H(t) H(t)，我们假设每个边缘节点在每个时隙结束时广播其活动队列的数量。即使边缘节点上的所有 M M M个队列都处于活动状态，活动队列的数量也可以用 ⌊ l o g 2 M ⌋ + 1 ⌊log_2M⌋+1 ⌊log2M⌋+1位表示。例如，如果有1000个移动设备，那么最多需要10位。（二进制，队列不一定是从时隙最开始进行，所以用floor函数➕1）因此，大量活动队列的广播只会产生少量的信令开销。
在时隙 t ∈ T t\mathcal{\in T} t∈T的开始，每个设备 m ∈ M m\mathcal{\in M} m∈M观察其状态信息，包括任务大小、队列信息和边缘节点的负载水平历史。具体来说，移动设备 m m m遵循以下状态：

由于边缘节点的负载动态未知，在做出任务卸载决策时，边缘节点上任务的排队延迟未知。因此，我们没有将其作为国家信息。此外，我们提出的算法的运行不依赖于边缘节点的这种排队延迟。

其中向量 q m e d g e ( t − 1 ) = ( q m , n e d g e ( t − 1 ) ， n ∈ N ) q_m^{edge}(t-1)=(q_{m,n}^{edge}(t-1)，n\mathcal{\in N}) qmedge(t−1)=(qm,nedge(t−1)，n∈N)，用 S \mathcal S S表示每个移动设备的离散和有限状态空间，即 S = Λ × { 0 , 1 , . . . T } 2 × Q N × { 0 , 1 , . . . M } T s t e p × N \mathcal S=\Lambda\times\{0,1,...T\}^2\times \mathcal Q^N\times\{0,1,...M\}^{T^{step}\times N} S=Λ×{0,1,...T}2×QN×{0,1,...M}Tstep×N，其中 Q \mathcal Q Q表示 T T T个时隙内边缘节点处队列长度的可用值集。注意，移动设备 m ∈ M m\mathcal{\in M} m∈M可以通过时隙 t t t开始时的局部观测获得状态信息 λ m ( t ) \lambda_m(t) λm(t)， δ m c o m p ( t ) \delta_m^{comp}(t) δmcomp(t)和 δ m t r a n ( t ) \delta_m^{tran}(t) δmtran(t)。(时隙t开头新到达的位数，放在计算队列，传输队列等待的时隙数)同时，移动设备M可以根据（8）局部计算 q m e d g e ( t − 1 ) q_m^{edge}(t-1) qmedge(t−1)。(上一个时隙结束时设备队列长度)具体来说，移动设备知道它在每个时隙中传输到边缘节点的比特数。此外，它还可以计算每个边缘节点在每个时隙中已处理或丢弃的比特数。

3.2动作

在时隙 t ∈ T t\mathcal{\in T} t∈T的开始，如果移动设备 m ∈ N m\mathcal{\in N} m∈N具有新的任务 k m ( t ) k_m(t) km(t)到达，那么它将为任务 k m ( t ) k_m(t) km(t)选择操作：（a）是本地处理任务还是将其卸载到边缘节点，即 x m ( t ) x_m(t) xm(t)；（b）任务卸载到哪个边缘节点，即 y m ( t ) y_m(t) ym(t)。因此，设备 m m m在时隙 t t t中的动作由以下动作向量表示：
让 A \mathcal A A表示动作空间，即 A = { 0 , 1 } 1 + N \mathcal A=\{0,1\}^{1+N} A={0,1}1+N。（？？）

3.3成本

如果任务已被处理，则任务的延迟是任务到达与任务已被处理之间的持续时间。(任务的延迟包括排队延迟、处理延迟和传输延迟（如果任务已卸载）。移动设备可以通过计算任务到达和处理任务之间的持续时间来确定任务的延迟，而不是单独计算这些延迟然后将其相加。)
给定状态 s m ( t ) s_m(t) sm(t)和动作 a m ( t ) a_m(t) am(t)，让延迟 D e l a y \rm{Delay} Delay m ( s m ( t ) , a m ( t ) ) _m(s_m(t),a_m(t)) m(sm(t),am(t))（在时隙中）表示任务 k m ( t ) k_m(t) km(t)的延迟。对于 m ∈ M m\mathcal{\in M} m∈M和 t ∈ T t\mathcal{\in T} t∈T，如果 x m ( t ) = 1 x_m(t)=1 xm(t)=1，则
（本地）那么延迟=处理完的间隙-进入的间隙+1 （15）

如果 x m ( t ) = 0 x_m(t)=0 xm(t)=0，则

（l 在边缘节点被处理或丢弃的时隙）
如果任务 k m ( t ) k_m(t) km(t)在时隙 t ′ t' t′之前发送到边缘节点 n n n，那么 k m , n e d g e ( t ′ ) = k m ( t ) k_{m,n}^{edge}(t')=k_m(t) km,nedge(t′)=km(t)。

具体来说，考虑任务 k m ( t ) k_m(t) km(t)在时隙 t t t的开头到达。如果任务 k m ( t ) k_m(t) km(t)被放置在计算队列中用于本地处理，那么 l m c o m p ( t ) l_m^{comp}(t) lmcomp(t)是任务被处理完的时隙。如果任务 k m ( t ) k_m(t) km(t)被放置在传输队列中进行卸载，则 ∑ n ∈ N ∑ t = t ′ T I ( k m , n e d g e ( t ′ ) = k m ( t ) ) l m , n e d g e ( t ′ ) \sum_{n\mathcal{\in\mathcal{N}}}\sum_{t=t'}^T\Bbb {I} (k_{m,n}^{edge}(t')=k_m(t))l_{m,n}^{edge}(t') ∑n∈N∑t=t′TI(km,nedge(t′)=km(t))lm,nedge(t′)是任务已被处理的时隙。，这是因为 I ( k m , n e d g e ( t ′ ) = k m ( t ) ) = 1 \Bbb {I} (k_{m,n}^{edge}(t')=k_m(t))=1 I(km,nedge(t′)=km(t))=1表示在时隙 t ′ t' t′开始时边缘节点 n ∈ N n\mathcal{\in N} n∈N的队列任务 k m ( t ) k_m(t) km(t)已经到达， l m , n c o m p ( t ′ ) l_{m,n}^{comp}(t') lm,ncomp(t′)是在时隙 t ′ t' t′开始时边缘节点 n n n上设备 m m m的任务已经被处理的时隙。
与任务 k m ( t ) k_m(t) km(t)相关的成本是 c m ( s m ( t ) , a m ( t ) ) c_m(s_m(t),a_m(t)) cm(sm(t),am(t))。如果任务 k m ( t ) k_m(t) km(t)被处理，则

另一方面，如果任务 k m ( t ) k_m(t) km(t)被丢弃，则

其中 C > 0 C>0 C>0是一个常数惩罚。在不损失一般性的情况下，如果任务 k m ( t ) = 0 k_m(t)=0 km(t)=0，则设置 c m ( s m ( t ) , a m ( t ) ) = 0 c_m(s_m(t),a_m(t))=0 cm(sm(t),am(t))=0。在这项工作的剩余部分，我们使用短格式 c m （ t ） c_m（t） cm（t）来表示 c m ( s m ( t ) , a m ( t ) ) c_m(s_m(t),a_m(t)) cm(sm(t),am(t))。请注意，在实际系统中，可能存在其他类型的成本，例如能源消耗和边缘节点收取的订阅费。这些成本可以通过在等式(17)和(18)中包含相应的项来纳入本工作。由于所提出的基于DRL的算法是一种无模型方法，因此它仍然适用于扩展场景。

3.4问题制定

设备 m ∈ M m\mathcal{\in M} m∈M政策是从状态到动作的映射，即 π m : S → A π_m:\mathcal S \rightarrow \mathcal A πm:S→A。用 γ ∈ ( 0 , 1 ] \gamma\in(0,1] γ∈(0,1]表示未来折扣成本的折扣系数。（伽马折扣率）我们的目标是找到每台设备 m m m最优策略 π m ∗ π_m^* πm∗，使其预期长期成本最小化，即
（时间越久，影响越小）

期望 E [ ⋅ ] \Bbb E[·] E[⋅]与时变系统参数有关，例如所有移动设备的任务到达和任务的计算要求，以及除设备 m m m以外的移动设备的决定。

4.基于DRL的卸载算法

在本节中，我们提出了一种基于DRL的卸载算法，该算法支持每个移动设备的分布式卸载决策。该算法基于深度Q学习[17]。由于深度Q学习是一种无模型的方法，该算法可以解决复杂的系统设置和移动设备之间的交互，而不需要系统和交互动力学的先验知识。同时，该算法可以处理系统潜在的大状态空间。
在该算法中，每个移动设备的目标是获得从每个状态-动作对到Q值的映射，这反映了状态行动对的预期长期成本。映射由神经网络确定。根据映射，每个设备可以选择其状态下的最小Q值，以最小化预期的长期成本。下面，我们分别介绍了神经网络和基于DRL的算法。

4.1神经网络

神经网络的目标是找到从每个状态到动作的一组Q值的映射。图2显示了移动设备 m ∈ M m\mathcal{\in M} m∈M的神经网络示意图。具体来说，状态信息通过输入层传递到神经网络，然后用LSTM层根据负载水平历史预测近期的负载水平（在边缘节点），通过两个完全连接的（FC）层学习从所有状态（负载水平历史记录除外）和预测负载水平到Q值的映射。同时，通过优势和价值（A&V）层，决斗DQN技术[25]来提高从状态到Q值映射的学习效率。最后，在输出层确定动作的Q值。设 θ m \theta_m θm表示设备 m m m的神经网络的参数向量，其中包括从输入层到A&V层的所有连接的权重和所有神经元的偏差。每一层的细节如下。

4.1.1输入层

该层负责将状态作为输入，并将其传递给以下层。对于设备 m ∈ M m\mathcal{\in M} m∈M，状态信息 λ m ( t ) \lambda_m(t) λm(t), δ m c o m p ( t ) , δ m t r a n ( t ) , q m e d g e ( t − 1 ) \delta_m^{comp}(t),\delta_m^{tran}(t),q_m^{edge}(t-1) δmcomp(t),δmtran(t),qmedge(t−1)将被传递到FC层， H ( t ) \boldsymbol H(t) H(t)将被传递到LSTM层以进行负载水平预测。

4.1.2 LSTM层（预测下一个时隙的负载水平）

该层负责学习边缘节点负载水平的动态，并预测近期的负载水平。LSTM是一种广泛使用的方法，用于学习连续观测的时间依赖性和预测时间序列的未来变化。
具体来说，LSTM网络将矩阵 H ( t ) \boldsymbol H(t) H(t)作为输入去学习负载水平动态。LSTM网络包含 T s t e p T^{step} Tstep个单元，每个单元包含一组隐藏神经元。每个LSTM单元取一行 H ( t ) \boldsymbol H(t) H(t)作为输入，我们让 { H ( t ) } i \{\boldsymbol H(t)\}_i {H(t)}i记为 H ( t ) \boldsymbol H(t) H(t)中第 i i i行。这些LSTM单元按顺序连接，以便跟踪从 { H ( t ) } 1 \{\boldsymbol H(t)\}_1 {H(t)}1到 { H ( t ) } T s t e p \{\boldsymbol H(t)\}_{T^{step}} {H(t)}Tstep序列的变化，可以体现各时隙边缘节点的负载水平变化。LSTM网络将在最后一个LSTM单元中输出指示未来负载水平动态的信息，输出将传递到下一层以供进一步学习。

4.1.3 FC层

（将卷积层提取的特征综合起来，减少参数，防止过拟合）
两个FC层负责学习从状态和学习的负载水平动态到动作Q值的映射。每个FC层包含一组带有整流线性单元（ReLU）的神经元，这些神经元与前一层和后一层的神经元相连。

4.1.4 A&V层和输出层

A&V层和输出层实施决斗DQN技术[25]，并确定每个环节的Q值作为输出。决斗DQN的主要思想是首先分别状态价值（即状态产生的Q值部分）和动作优势值（即行动产生的Q值部分）。然后，它使用状态价值和动作优势值来确定状态-动作对的Q值。这种技术可以通过分别评估一种状态和一种行为产生的预期长期成本来改进Q值的估计。（很多Q值受当前状态影响，无论采取什么动作影响不大）
A&V层包含两个网络，由网络A和网络V表示（见图2）。A网络包含一个 FC网络，它负责了解每个动作 a ∈ A a \mathcal{\in A} a∈A的动作优势价值。对于移动设备 m ∈ M m \mathcal{\in M} m∈M，用 A m ( s m ( t ) , a ; θ m ) A_m(s_m(t),a;\theta_m) Am(sm(t),a;θm)表示动作 a a a在状态 s m ( t ) ∈ S s_m(t)\mathcal{\in S} sm(t)∈S网络参数 θ m \theta_m θm的动作优势价值。V网络包含一个 FC网络，它代表状态价值。对于移动设备 m m m，用 V m ( s m ( t ) ; θ m ) V_m(s_m(t);\theta_m) Vm(sm(t);θm)表示在状态 s m ( t ) s_m(t) sm(t)网络参数 θ m \theta_m θm的状态价值。 A m ( s m ( t ) , a ; θ m ) A_m(s_m(t),a;\theta_m) Am(sm(t),a;θm)和 V m ( s m ( t ) ; θ m ) V_m(s_m(t);\theta_m) Vm(sm(t);θm)由参数向量 θ m \theta_m θm和神经网络结构决定，从输入层到A&V层，其中向量 θ m \theta_m θm可调，将在基于DRL的算法中进行训练。
基于A&V层，对于移动设备 m ∈ M m \mathcal{\in M} m∈M，动作 a a a在状态 s m ( t ) ∈ S s_m(t)\mathcal{\in S} sm(t)∈S的Q值在输出层表示如下[25]：
Q m ( s m ( t ) , a ; θ m ) = V m ( s m ( t ) ; θ m ) + ( ( A m ( s m ( t ) , a ; θ m ) − 1 ∣ A ∣ ∑ a ′ ∈ A A m ( s m ( t ) , a ′ ; θ m ) ) . (20) Q_m(s_m(t),a;\theta_m)=V_m(s_m(t);\theta_m)+((A_m(s_m(t),a;\theta_m)\\-\frac{1}{\mathcal{|A|}}\sum_{a'\mathcal{\in\mathcal{A}}}A_m(s_m(t),a';\theta_m)).\tag{20} Qm(sm(t),a;θm)=Vm(sm(t);θm)+((Am(sm(t),a;θm)−∣A∣1a′∈A∑Am(sm(t),a′;θm)).(20)
它是对应状态下的状态值与对应动作的附加动作优势值之和（相对于所有动作在该状态下的平均动作优势值）。（a-a平均表示动作a对状态有益或者损害）

4.2基于DRL的算法

在我们提出的基于DRL的算法中，我们让边缘节点帮助移动设备训练神经网络，以减轻移动设备的计算负载。具体来说，对于每个移动设备 m ∈ M m \mathcal{\in M} m∈M，有一个边缘节点 n m ∈ N n_m\mathcal{\in N} nm∈N这有助于设备 m m m的训练。该边缘节点 n m n_m nm可以是移动设备传输容量最大的边缘节点。为了展示的方便，用 M n ⊂ M M_n\subset\mathcal{M} Mn⊂M表示由边缘节点 n ∈ N n\mathcal{\in N} n∈N执行训练的移动设备集，即 M n = { m ∈ M ∣ n m = n } \mathcal{M_n} =\{m\mathcal{\in M}|n_m=n\} Mn={m∈M∣nm=n}。
算法1和算法2分别给出了在移动设备 m ∈ M m \mathcal{\in M} m∈M和边缘节点 n ∈ N n\mathcal{\in N} n∈N上执行的基于DRL的算法。该算法的核心思想是利用移动设备的经验（即状态、动作、代价和下一个状态）训练神经网络，以获得从状态-动作对到Q值的映射，基于此，移动设备可以在观察到的状态下选择导致最小Q值的动作，以最小化其预期的长期代价。
在基于DRL的算法中，边缘节点 n ∈ N n\mathcal{\in N} n∈N为设备 m ∈ M n m \mathcal{\in M_n} m∈Mn维护回放存储器 D m D_m Dm。回放存储器 D m D_m Dm存储 t ∈ T t \mathcal{\in T} t∈T时刻设备 m m m的观测经验 ( s m ( t ) , a m ( t ) , c m ( t ) , s m ( t + 1 ) ) (s_m(t),a_m(t),c_m(t),s_m(t+1)) (sm(t),am(t),cm(t),sm(t+1))，其中我们将 ( s m ( t ) , a m ( t ) , c m ( t ) , s m ( t + 1 ) ) (s_m(t),a_m(t),c_m(t),s_m(t+1)) (sm(t),am(t),cm(t),sm(t+1))称为移动设备 m m m的经验。同时，边缘节点 n ∈ N n\mathcal{\in N} n∈N为设备 m ∈ M n m \mathcal{\in M_n} m∈Mn维护两个神经网络，包括一个评估网络（用 N e t m \rm{Net_m} Netm表示）和一个目标网络（用 T a r g e t _ N e t m \rm{Target\_Net_m} Target_Netm表示）。评估网络 N e t m \rm{Net_m} Netm用于行动选择。用于表征目标Q值的目标网络 T a r g e t _ N e t m \rm{Target\_Net_m} Target_Netm，其近似于观察状态下行动的预期长期成本。该目标Q值将用于通过最小化 N e t m \rm{Net_m} Netm下的Q值和目标Q值之间的差异来更新 N e t m \rm{Net_m} Netm（TD error）。请注意， N e t m \rm{Net_m} Netm和 T a r g e t _ N e t m \rm{Target\_Net_m} Target_Netm具有相同的神经网络结构，如第4.1节所示，而它们分别有不同的网络参数向量 θ m \theta_m θm和 θ m − \theta_m ^- θm−。（网络结构相同但是网络参数不同固定目标值消除连续动作相关性）因此， N e t m \rm{Net_m} Netm和 T a r g e t _ N e t m \rm{Target\_Net_m} Target_Netm的在状态 s m ( t ) ∈ S s_m(t)\mathcal{\in S} sm(t)∈S和动作 a ∈ A a \mathcal{\in A} a∈A的Q值分别 Q m ( s m ( t ) , a ; θ m ) Q_m(s_m(t),a;\theta_m) Qm(sm(t),a;θm)和 Q m ( s m ( t ) , a ; θ m − ) Q_m(s_m(t),a;\theta_m^-) Qm(sm(t),a;θm−)表示。重放存储器 D m D_m Dm和两个神经网络的初始化在算法2的步骤1-3中给出。

4.2.1移动设备 m ∈ M m\mathcal{\in M} m∈M上的算法1

我们考虑多个情节，情节的数量用 E E E表示。在每个情节开始时，移动设备 m ∈ M m \mathcal{\in M} m∈M初始化状态，即，
s m ( 1 ) = ( λ m ( 1 ) , δ m c o m p ( 1 ) , δ m t r a n ( 1 ) , q m e d g e ( 0 ) , H ( 1 ) ) (21) s_m(1)=(\lambda_m(1),\delta_m^{comp}(1),\delta_m^{tran}(1),q_m^{edge}(0),H(1))\tag{21} sm(1)=(λm(1),δmcomp(1),δmtran(1),qmedge(0),H(1))(21)
其中，我们为所有边缘节点 n ∈ N n\mathcal{\in N} n∈N设置 q m e d g e ( 0 ) q_m^{edge}(0) qmedge(0)， H ( 1 ) H(1) H(1)是一个大小为 T s t e p × N T^{step}\times N Tstep×N的零矩阵。在时隙 t ∈ T t\mathcal{\in T} t∈T开始时，如果移动设备 m m m有一个新的任务 k m ( t ) k_m(t) km(t)到达，那么它将向边缘节点 n m n_m nm发送一个参数请求，以更新其用于做出任务卸载决策的参数向量 θ m \theta_m θm。(MD计算有限，通过边缘节点帮助训练，减小计算负载)为了减少通信开销，解决神经网络参数传输带来的潜在可扩展性问题，移动设备可能不会在每次任务到达时都请求参数向量。也就是说，在某些时隙中，可以省略算法1中的步骤5-6。直观地说，当移动设备请求参数向量的频率很小时，通信开销也会很小。然而，这可能会降低算法的收敛速度。在第5.1节中，我们根据经验评估了这种频率对算法收敛性的影响。
基于 N e t m \rm{Net_m} Netm的参数向量 θ m \theta_m θm，移动设备 m m m将为任务 k m ( t ) k_m(t) km(t)选择其动作，如下所示：

其中，'w.p.'是“有概率”的缩写形式， ε \varepsilon ε是随机探索的概率。直观地说，根据概率 1 − ε 1-\varepsilon 1−ε，设备在 n ∈ N n\mathcal{\in N} n∈N下选择导致状态 s m ( t ) s_m(t) sm(t)下最小Q值的动作。
在下一个时隙开始（即时隙 t + 1 t+1 t+1）时，移动设备 m m m观察下一个状态 s m ( t + 1 ) s_m(t+1) sm(t+1)。另一方面，由于任务的处理和传输可能会在多个时隙中继续，因此，取决于任务 k m ( t ) k_m(t) km(t)的延迟的成本 c m ( t ) c_m(t) cm(t)可能不会在时隙 t + 1 t+1 t+1开始时被观察到。相反，移动设备 m m m可能观察到一组属于时隙 t ′ ≤ t t' \leq t t′≤t的任务 k m ′ ( t ) k'_m(t) km′(t)的成本。为了解决这个问题，对于设备 m m m，我们将 T ~ m , t ⊂ T \widetilde{\mathcal{T}}_{m,t}\subset\mathcal{T} T m,t⊂T定义为一组时隙，使得与时隙 t ′ ∈ T ~ m , t t'\mathcal{\in \widetilde{\mathcal{T}}_{m,t}} t′∈T m,t相关联的每个任务 k m ′ ( t ) k'_m(t) km′(t)已在时隙中被处理或丢弃。集合 T ~ m , t \widetilde{\mathcal{T}}_{m,t} T m,t的定义如下:
在(23)中， λ m ( t ′ ) > 0 \lambda_m(t')>0 λm(t′)>0意味着在时隙 t ′ t' t′中有一个新到达的任务 k m ( t ′ ) k_m(t') km(t′)。具体来说，如果 k m ( t ′ ) k_m(t') km(t′)已在时隙 t t t中处理或删除， T ~ m , t \widetilde{\mathcal{T}}_{m,t} T m,t包含一个时隙 t ′ ∈ { 1 , 2 , . . . t } t'\in\{1,2,...t\} t′∈{1,2,...t}。因此，在时隙 t + 1 t+1 t+1开始时，移动设备 m m m可以观察到一组成本 { c m ( t ′ ) , t ′ ∈ T ~ m , t } \{c_m(t'),t'\mathcal{\in \widetilde{\mathcal{T}}_{m,t}}\} {cm(t′),t′∈T m,t}，其中 T ~ m , t \widetilde{\mathcal{T}}_{m,t} T m,t可以是某个 m ∈ M m\mathcal{\in \mathcal{M}} m∈M和 t ∈ T t\mathcal{\in \mathcal{T}} t∈T的空集。然后，对于每个任务 k m ( t ′ ) k_m(t') km(t′)和 t ′ ∈ T ~ m , t t'\mathcal{\in \widetilde{\mathcal{T}}_{m,t}} t′∈T m,t，设备 m m m将其经验 ( s m ( t ′ ) , a m ( t ′ ) , c m ( t ′ ) , s m ( t ′ + 1 ) ) (s_m(t'),a_m(t'),c_m(t'),s_m(t'+1)) (sm(t′),am(t′),cm(t′),sm(t′+1))发送给边缘节点 n m n_m nm。请注意，当设备 m m m发送状态信息 s m ( t ′ ) s_m(t') sm(t′)和 s m ( t ′ + 1 ) s_m(t'+1) sm(t′+1)时，它不需要发送负载级别历史记录 H ( t ′ ) H(t') H(t′)和 H ( t ′ + 1 ) H(t'+1) H(t′+1)。这是因为每个时隙中边缘节点上的活动队列数是通过广播发送的。因此，每个边缘节点都知道过去时间段内所有边缘节点的负载水平历史。在这种情况下，当边缘节点接收到经验 ( s m ( t ′ ) , a m ( t ′ ) , c m ( t ′ ) , s m ( t ′ + 1 ) ) (s_m(t'),a_m(t'),c_m(t'),s_m(t'+1)) (sm(t′),am(t′),cm(t′),sm(t′+1))时，它可以将 H ( t ′ ) H(t') H(t′)和 H ( t ′ + 1 ) H(t'+1) H(t′+1)包含到用于训练的经验中。

4.2.2边缘节点 n ∈ N n\mathcal{\in N} n∈N上的算法2

初始化回放存储器 D m D_m Dm以及设备 m ∈ M n m \mathcal{\in M_n} m∈Mn的神经网络 N e t m \rm{Net_m} Netm和 T a r g e t _ N e t m \rm{Target\_Net_m} Target_Netm，每个边缘节点 n ∈ N n\mathcal{\in N} n∈N将等待来自 M n \mathcal{M_n} Mn集移动设备的请求消息。如果边缘节点 n n n接收到来自移动设备 m ∈ M n m \mathcal{\in M_n} m∈Mn的参数请求，那么它将向移动设备 m m m发送 N e t m Net_m Netm的当前参数向量 θ m \theta_m θm。另一方面，如果边缘节点 n n n从移动设备 m ∈ M n m \mathcal{\in M_n} m∈Mn接收到经验 ( s m ( t ) , a m ( t ) , c m ( t ) , s m ( t + 1 ) ) (s_m(t),a_m(t),c_m(t),s_m(t+1)) (sm(t),am(t),cm(t),sm(t+1))，则其将该经验存储在存储器 D m D_m Dm中。参数向量的回应（算法2中的步骤5-7）和网络的训练（算法2中的步骤8-21）可以并行操作。也就是说，当边缘节点接收到来自移动设备 m m m的参数请求时，它将立即向设备发送当前向量 θ m \theta_m θm，而不管是否有正在进行的训练。
边缘节点将训练神经网络（在算法2中步骤10−20）更新 N e t m \rm{Net_m} Netm的参数向量 θ m \theta_m θm如下。边缘节点将从内存中随机抽取一组经验（在步骤10中），用 I \mathcal{I} I表示。让 ∣ I ∣ \mathcal{|I|} ∣I∣表示集合 I \mathcal{I} I中的经验数。基于这些经验样本，更新 N e t m \rm{Net_m} Netm的关键思想是最小化 N e t m \rm{Net_m} Netm下的Q值与基于 T a r g e t _ N e t m \rm{Target\_Net_m} Target_Netm下的经验样本计算的目标Q值之间的差异。具体来说，对于集合 I \mathcal{I} I中的经验样本，边缘节点将通过最小化以下损失函数来计算 Q ^ m T a r g e t = ( Q ^ m , n T a r g e t , i ∈ I ) \hat{Q}_{m}^{\rm{Target}}=(\hat{Q}_{m,n}^{\rm{Target}},i\mathcal{\in I}) Q^mTarget=(Q^m,nTarget,i∈I)并更新 N e t m \rm{Net_m} Netm中的 θ m \theta_m θm:

损失函数（24）描述了当前网络参数向量 θ m \theta_m θm下给定状态 s m ( i ) s_m(i) sm(i)动作 a m ( i ) a_m(i) am(i)的Q值与每个经验 i ∈ I i \mathcal{\in I} i∈I（将在下一段中解释）的目标Q值 Q ^ m , i T a r g e t \hat{Q}_{m,i}^{\rm{Target}} Q^m,iTarget之间的差距。损耗函数的最小化是通过使用迭代优化算法（如梯度下降算法）对神经网络进行反向传播（见[27]第6节）来完成的。
经验 i ∈ I i \mathcal{\in I} i∈I的目标Q值 Q ^ m , i T a r g e t \hat{Q}_{m,i}^{\rm{Target}} Q^m,iTarget是基于双DQN技术[28]确定的，与传统方法（例如[17]）相比，它可以改进对预期长期成本的估计。为了推导该目标Q值，让 a i N e x t a_i^{Next} aiNext表示在 N e t m \rm{Net_m} Netm下给定状态 s m ( i + 1 ) s_m(i+1) sm(i+1)的最小Q值的动作，即
Q ^ m , i T a r g e t \hat{Q}_{m,i}^{\rm{Target}} Q^m,iTarget的值对于经验 i i i推导如下：

直观地说，目标Q值 Q ^ m , i T a r g e t \hat{Q}_{m,i}^{\rm{Target}} Q^m,iTarget反映了给定状态 s m ( i ) s_m(i) sm(i)动作 a m ( i ) a_m(i) am(i)下的预期长期行动成本，即经验 i i i成本和网络 T a r g e t _ N e t m \rm{Target\_Net_m} Target_Netm下的折扣Q值之和(下一状态经验不足)。
让Replace_Threshold表示更新 T a r g e t _ N e t m \rm{Target\_Net_m} Target_Netm的培训轮数。也就是说，对于每一轮Replace_Threshold训练，必须通过复制 N e t m \rm{Net_m} Netm的参数向量来更新 T a r g e t _ N e t m \rm{Target\_Net_m} Target_Netm，其中mod（·）是模运算符（在算法2中的步骤18中）。这一步的目的是使 T a r g e t _ N e t m \rm{Target\_Net_m} Target_Netm中的网络参数 θ m − \theta_m^- θm−保持最新，以便在计算（26）中的目标Q值时，它能更好地近似预期的长期成本。

4.2.3计算复杂度和收敛性

要确定计算复杂度，请注意神经网络中乘法运算的数量。一次经验训练的反向传播计算复杂度是 O ( L ) \mathcal O(L) O(L)。回想一下， ∣ I ∣ \mathcal |I| ∣I∣是在每一轮培训中取样的经验数量。用 K K K表示每个事件中的预期任务数。由于存在E个片段，该算法的计算复杂度为是 O ( L K E ∣ I ∣ ) \mathcal O(LKE|I|) O(LKE∣I∣)。
关于收敛性，正如许多现有工作（例如[29]）中提到的，DRL算法的收敛保证仍然是一个开放的问题。尽管强化学习算法的收敛性是可以证明的，但DRL算法需要使用神经网络进行函数逼近（例如，深度Q学习算法中Q值的逼近），在这种情况下，收敛性可能不再得到保证。在这项工作中，我们将对第5.1节中提出的算法的收敛性能进行实证评估。

5.绩效评估

我们考虑具有50个移动设备和五个边缘节点的场景。参数设置如表1所示。神经网络设置如下。批量大小设置为16。学习率等于0.001，折扣系数等于0.9。随机勘探的概率从1逐渐降低到0.01。同时，我们使用RMSProp优化器。在这些模拟中，我们将重点放在具有静态环境的场景上，即过渡函数（从状态和动作到下一个状态）和成本函数（从状态和动作到成本）不会随时间变化。在非平稳环境下，如果环境发生了变化，则该算法可以通过将随机探索的概率设置为1来适应，从而再次启用随机探索。

5.1性能和收敛

提出的算法中的神经网络是在线训练的，实时收集的经验用于训练神经网络和更新任务卸载决策。我们在不同的神经网络超参数和算法设置下评估了算法的收敛性。我们考虑1000段，每一段有100个时隙。
模拟结果如图4所示。在这些子图中，x轴显示的是段，y轴显示的是移动设备的平均成本以及每段的时段。我们绘制了该算法在不同设置和随机策略（用“Rand”表示）下的性能图，这些动作是随机选择的。

图4（a）显示了所提出的算法在不同学习率值（表示为“lr”）下的收敛性，其中学习率是每次迭代中朝向损失函数最小值的步长。在图4（a）中，lr= 1 0 − 3 10^{-3} 10−3导致相对较快的收敛速度和较小的收敛成本。当学习率较低时（即 1 0 − 4 10^{-4} 10−4），收敛缓慢。当学习率较高时（即 1 0 − 2 , 1 0 − 1 10^{-2},10^{-1} 10−2,10−1），聚合成本(?)增加，这可能比随机策略的成本更高。
图4（b）显示了不同批量下的算法性能，即每轮培训中采样的经验数。当批量大小从2增加到8时，收敛速度加快。当它从8增加到32时，该算法的性能在收敛速度和收敛结果方面没有显著提高。因此，我们可以选择最小批量（例如8）来减少一轮训练的时间，而不会显著降低所提出算法的性能。
图4（c）显示了不同优化器下的算法性能，包括梯度下降（用“GD”表示）、RMSProp和自适应矩估计（Adam）优化器。这些优化器提供了不同的方法来更新神经网络，以最小化（24）中的损失函数。如图4（c）所示，RMSProp和Adam优化器的收敛速度和结果类似。
在图4（d）中，我们考虑一个设置，其中移动设备终止参数请求，以更新其网络参数每一固定数量的时隙（而不是当移动设备有任务到达时的每个时隙）。如图所示，每100个时隙发送一次请求与每次发送相比，对算法性能没有太大影响。这是因为该算法中的神经网络训练是基于从经验回放中随机抽样而不是新获得的经验。因此，该算法可以容忍一定程度的延迟，以更新用于动作选择的神经网络。因此，为了减少通信开销，我们可以在不显著影响算法性能的情况下降低参数请求的发送频率。

5.2方法比较

我们将我们提出的基于DRL的方法与几种基准方法进行比较，包括无卸载（用no Offl.表示），随机卸载（由R.Offl.表示），PGOA[14]和ULOF [15]。PGOA是基于潜在博弈的最佳响应算法设计的，该算法考虑了移动设备之间的战略交互。ULOF是根据历史观察结果进行容量估算而设计的。我们选择PGOA和ULOOF进行比较，因为与我们的工作类似，这些方案考虑了不可分割任务和多个边缘节点，并且他们没有考虑任何集中实体的参与。我们考虑两个性能指标：下降的任务的比率（即，下降的任务数到总任务到达数的比率）和平均延迟（即，已处理的任务的平均延迟）。
(PGOA的工作假设是每个任务的处理可以在每个时隙内完成。因此，每个任务的卸载决策可以基于在前一个时隙中到达的任务的反馈（例如延迟）来做出。在我们的工作中，我们没有强加这种假设。为了评估性能，我们考虑每个任务的卸载决策是基于在以前的时隙中已经处理过的任务的反馈。)

在图5(a)中，随着任务到达概率的增加，与基准方法相比，所提出的基于DRL的算法始终可以保持较低的任务丢弃率。当任务到达概率很小（即0.1）时，大多数方法可以实现约为零的延迟任务比率。随着任务到达概率从0.1增加到0.5该算法的任务丢弃率保持在0.2以下。而基准方法的比例增加到0.5以上。5(b)随着任务到达概率从0.1增加到0.4，我们提出的基于DRL的算法的平均延迟增加了26.1%，而基准方法的增长率至少为34.5%。这意味着随着系统负载的增加，提出的算法的平均延迟增加的幅度小于基准方法。随着任务到达概率增加到0.6一些方法的平均延迟减少了，因为越来越多的任务被丢弃，因此没有计入平均延迟。出于同样的原因，当系统负载较高时，所提出的算法可能比其他方法具有更大的平均延迟，因为它具有更少的任务丢弃。（任务丢弃率少负载大时延时大）

如图6(a)所示，与基准测试方法相比，所提出的算法总是能获得更低的任务丢弃率，尤其是在截止时间较短的情况下。当任务截止日期为0.6时。与基准方法相比，该算法将丢弃任务的比率降低了65.8%−79.3%。在图6(b)中，随着任务截止时间的增加，每种方法的平均延迟增加并逐渐收敛。这是因为当截止日期更大时，需要更长处理（和传输）时间的任务可以被处理，并计入平均延迟。当最后期限足够大时，没有任务被丢弃，因此进一步增加最后期限没有什么区别。如图6(b)所示，在截止时间增加到1.4后，所提出算法的平均延迟收敛（即，实现小于0.05的略微增加），收敛平均延迟约为0.54秒。相比之下，其他方法的收敛平均延迟都大于0.84秒。

在图7（a）中，与其他方法相比，所提出的算法实现了较低的任务丢弃率，尤其是在设备数量较大的情况下。这是因为提出的算法可以有效地解决边缘节点的未知负载动态问题。当移动设备的数量增加到80个时，所提出的算法将丢弃任务的比率保持在小于0.05，在图7（b）中，随着移动设备数量的增加，由于边缘节点的负载可能增加，每种方法的平均延迟（不卸载除外）都会增加。由于该算法能有效地处理未知的负载动态，当移动设备数量增加到150时，比PGOA和ULOF的平均延迟低9.0%。

6结论

在这项工作中，我们研究了MEC系统中具有不可分割和延迟敏感任务的计算任务卸载问题。我们设计了一种分布式卸载算法，使移动设备能够以分散的方式做出卸载决策，从而解决边缘节点未知的负载水平动态问题。仿真结果表明，与几种基准点方法相比，我们提出的算法可以降低任务丢失率和平均延迟。当任务对延迟敏感或边缘节点的负载水平较高时，这种好处尤其重要。
有几个方向可以扩展这项工作。首先，扩展简化的无线网络模型，将传输误差和移动设备之间的干扰纳入其中，这很有趣。第二，可以在演示系统中评估算法性能，在演示系统中，需要解决许多实际问题（例如，实际计算任务）。第三，可以降低算法的计算复杂度。这可以通过结合深度压缩[31]来减少神经网络中乘法运算的数量，并结合转移学习[32]来加速收敛来实现。此外，当我们让边缘节点帮助移动设备训练神经网络时，当神经网络较大时，由于神经网络参数传输而导致的通信溢出和可伸缩性问题可能是一个值得关注的问题。为了扩展这项工作，可以应用深度压缩[31]来减少神经网络的权值数量和表示每个权值所需的位数。此外，为了提高该算法在非平稳环境下的性能，将非平稳环境下的强化学习（例如[33]）和终身强化学习[34]等技术结合起来是很有意思的。最后，博弈论和多智能体强化学习技术可用于进一步理解移动设备之间的策略交互。这些技术可以整合到所提出的算法中，以进一步解决边缘节点的负载水平动态问题。