Mobility

admin 管理员组

文章数量: 887021

Mobility

Mobility-Aware Cooperative Caching inV ehicular Edge Computing Based on Asynchronous Federated and Deep Reinforcement Learning

要解决的问题 Mobility-Aware、Cooperative Caching
背景 VEC（Vehicular Edge Computing）
方法 FL、DRL

文章的主要问题

1.车辆的移动，对于本地模型上传、全局模型的精度产生影响；用户数据隐私考虑。

• 用到异步联邦学习提高全局模型精度和保护用户数据隐私。

2.车辆的高移动性，先前请求内容可能会很快过时

• 用到FL中的全局模型，结合VU提前预测到可能的内容，缓存在合适的RSU路边站点。

3.本地存储有限，超出请求导致延时

• 用到DRL构建一种机制来决策联合缓存的方案。

围绕受欢迎内容如何预测，如何存储。即FL训练模型并使用全局模型预测内容；然后DRL来决策联合缓存的方案。

II.RELATED WORK

该部分主要是介绍对于VEC的其他研究方案。
主要论述了2个部分。一部分是非联合缓存，一部分是联合的缓存。但两种方式都没有同时考虑到VU的隐私性和机动性去设计联合缓存方案。

III.SYSTEM MODEL

A. System Scenario

提出一个三层的VEC架构：

1. MBS top tier
   存储大量的数据，当VU在本地和邻近RSU没有找到时会请求MBS，并直接与UV连接。
2. RSUs mid tier
   VU首先访问该站点，但该站点容量有限。对于访问到本都RSU时，直接返回数据；对于访问到的是邻近的RSU时，会先发到本地RSU再发给VU。
3. VUs btn tier（文章是vehicles，我觉得应该是一个东西）
   存储自己的历史数据，包括个人信息等。同时他会对内容有评级，用来表示感兴趣程度。

B. Mobility Model of Vehicles

提出一个场景模型，主要有轮次、车辆、车辆速度
在第 r 轮中，有 N^r 辆车，每辆车为 V_i^r (1 ≤ i ≤ N^r )，每辆车的速度为 U_i^r 。

有一个U的概率密度函数
f ( U i r ) = { e − 1 2 π α 2 ( U i r − α ) 2 2 π σ 2 ( e r f ( U m a x − μ σ 2 ) − e r f ( U m i n − μ σ 2 ) ) U m i n ≤ U i r ≤ U m a x , 0 o t h e r w i s e . f(U_i^r)=\left\{\begin{matrix}\frac{e^{-\frac{1}{2\pi\alpha^2}(U_i^r-\alpha)^2}}{\sqrt{2\pi\sigma^2}(erf(\frac{U_{max}-\mu}{\sigma\sqrt2})-erf(\frac{U_{min}-\mu}{\sigma\sqrt2}))}\\[6pt]U_{min}\leq U_i^r\leq U_{max},\\[6pt]0&otherwise.\end{matrix}\right. f(Uir​)=⎩ ⎨ ⎧​2πσ2 ​(erf(σ2 ​Umax​−μ​)−erf(σ2 ​Umin​−μ​))e−2πα21​(Uir​−α)2​Umin​≤Uir​≤Umax​,0​otherwise.​

C. Communication Model

提到 信道增益

两种链路V2R 和 V2B

以及二者的 传输速率 计算

IV. COOPERATIVE CACHING SCHEME

提出协同缓存方案。三步走：

A. Asynchronous Federated Learning （5steps）

1）Select Vehicles
选择的车辆能有足够的时间在本地RSU参与联邦学习 T r , i s t a y i n g > T t r a i n i n g + T i n f e r e n c e T_{r,i}^{staying}>T_{training}+T_{inference} Tr,istaying​>Ttraining​+Tinference​
2）Download Model
由本地RSU下载全局model到被选中的所有车辆中

3）Local Training

• 首先对各个表示解释一下

w：模型
r：轮次；
k：迭代次数；
i：具体车辆
W：权重矩阵；
b：偏置矩阵；
e，d：编码，解码
n：应该是采集的数据，文中说 |n| = number of data

• 本地训练是将下载的全局模型作为初始模型，进行 k 次迭代,达到规定的迭代次数后,上传到本地的RSU中,具体来说：
  ①.对输入数据进行编码，解码。 f（·）和 g（·）
  z ( x ) = f ( W i , k r , e x + b r , e ) z(x)=f\left(W^{r,e}_{i,k}x+b^{r,e}\right) z(x)=f(Wi,kr,e​x+br,e) 、 x ^ = g ( W i , k r , d z ( x ) + b i r , d ) \hat{x}=g\left(W^{r,d}_{i,k}z(x)+b^{r,d}_i\right) x^=g(Wi,kr,d​z(x)+bir,d​)

  ②.计算损失 l ( ω i , k r ; x ) = ( x − x ^ ) 2 l\left(\omega_{i,k}^r;x\right)=(x-\hat{x})^2 l(ωi,kr​;x)=(x−x^)2
  求了个平均 l o c a l l o s s f u n c t i o n f o r i t e r a t i o n k = f ( ω i , k r ) = 1 ∣ n i , k r ∣ ∑ x ∈ n i , k r l ( ω i , k r ; x ) local\ loss\ function\ for\ iteration\ k=f (\omega_{i,k}^r)=\dfrac{1}{\left|n_{i,k}^r\right|}\sum\limits_{x\in n_{i,k}^r}l\left(\omega^r_{i,k};x\right) local loss function for iteration k=f(ωi,kr​)= ​ni,kr​ ​1​x∈ni,kr​∑​l(ωi,kr​;x)
  ③.然后计算了 正则化局部损失函数，为了使得与原始的模型保持不是太大的偏差
  g ( ω i , k r ) = f ( ω i , k r ) + ρ 2 ∥ ω r − ω i , k ∥ 2 g\left(\omega_i,k^r\right)=f\left(\omega_{i,k}^r\right)+\dfrac{\rho}{2}\left\|\omega^r-\omega_{i,k}\right\|^2 g(ωi​,kr)=f(ωi,kr​)+2ρ​∥ωr−ωi,k​∥2
  ④.然后就是计算梯度，但是有一些stragglers，他在之前的轮次（r）中由于时间原因没能提交model，影响了全局model的整合。他会在 本论次 中将这些delayed梯度加到当前的梯度中
  ∇ ζ i , k r = ∇ g ( ω i , k r ) + β ∇ g i d \nabla\zeta_{i,k}^r=\nabla g(\omega_{i,k}^r)+\beta\nabla g_i^d ∇ζi,kr​=∇g(ωi,kr​)+β∇gid​
  此处的g（w）是 上式3 中的梯度，g_i^d是delayed的梯度
  ⑤.最后就是模型更新了
  ω i , k + 1 r = ω r − η l r ∇ ζ i , k r \omega^r_{i,k+1}=\omega^r-\eta^r_l\nabla\zeta^r_{i,k} ωi,k+1r​=ωr−ηlr​∇ζi,kr​

4）Upload Model
迭代次数带到规定e次后，V完成本地训练上传本地模型到RSU

5）Asynchronous aggregation
本地RSU根据收到的本地模型更新全局模型。具体来说，它根据每个车辆的权重对所有收到的本地模型进行加权平均，以获得更新后的全局模型。 ω r = ω r − 1 + d i r d r χ i ω i r , \omega^r=\omega^{r-1}+\frac{d_i^r} {d^r}\chi_i\omega_i^r, ωr=ωr−1+drdir​​χi​ωir​,

异步聚合权重X_i 的计算。受两个部分的影响：
一是：车辆在覆盖区域能走过的距离，越长则权重越高，因为有更多的时间参与到训练。
二是：与本地USR的内容传输延迟，越小也权重越高.(如果从本地 RSU 到 V_i^r的内容传输延迟较小，则其本地模型也应占用较大的权重进行聚合以减少内容传输延迟。
χ i = μ 1 ( L s − P i r ) + μ 2 s R R , i r \chi_i=\mu_1(L_s-P_i^r)+\mu_2\dfrac{s}{R_{R,i}^r} χi​=μ1​(Ls​−Pir​)+μ2​RR,ir​s​
然后可能是每个内容的大小s不便计算或者不是这个原因，
提到了另外一种计算方式： χ i = μ 1 ( L s − P i r ) L s + μ 2 R R , i r max ⁡ k ∈ N r ( R R , k r ) \chi_i=\mu_1\dfrac{(L_s-P_i^r)}{L_s}+\mu_2\dfrac{R_{R,i}^r}{\max_{k\in N^r}\left(R_{R,k}^r\right)} χi​=μ1​Ls​(Ls​−Pir​)​+μ2​maxk∈Nr​(RR,kr​)RR,ir​​

B. Popular Content Prediction

这部分价绍热门内容预测算法，主要分为 4步 去完成。

4步理解如下：

• 先对所有车辆现有内容感兴趣度做出矩阵初始化表示R
• 经过cos similarity计算，筛选出各自喜好比较类似的VUs，选出最好的K个
• 对这K个的矩阵行进行合并，得到矩阵H_K，并可以认为非零评分的内容就是V_i^r的感兴趣的内容，选出F_C个内容上传到RSU
• 然后由RSU，从所有上传的内容中选出F_C个内容作为受欢迎的内容

具体文章段落是：

1) Data Preprocessing

介绍了两种矩阵:
① 评分二维矩阵：每一行代表一个VU对所有内容的评分。
原始抽象的R矩阵经过AE输出模型的重建R^矩阵

② 个人信息矩阵：每一行代表一个VU的个人信息

2) Cosine Similarity

将1）中提到的两种矩阵经过组合为H_i^r 矩阵。
再通过余弦相似性计算VU之间的相似性。
能进行相似性的计算，同时需要该VU的非0评价内容数在所有VU中占到前 1/m ，也就是active VUs
sim a , b r , i = cos ⁡ ( H i r ( a , : ) , H i r ( b , : ) ) = H i r ( a , : ) ⋅ H i r ( b , : ) T ∥ H ( a , : ) ∥ 2 × ∥ H i r ( b , : ) ∥ 2 \text{sim}_{a,b}^{r,i}=\cos\left(\boldsymbol{H}_{i}^{r}(a,:),\boldsymbol{H}^{r}_{i}(b,:)\right)\\ =\dfrac{\boldsymbol{H}^r_{i}(a,:)\cdot\boldsymbol{H}^r_{i}\left(b,:\right)^{T}}{\left\|\boldsymbol{H}\left(a,:\right)\right\|_{2}\times\left\|\boldsymbol{\boldsymbol{H}}^r_{i}(b,:)\right\|_{2}} sima,br,i​=cos(Hir​(a,:),Hir​(b,:))=∥H(a,:)∥2​×∥Hir​(b,:)∥2​Hir​(a,:)⋅Hir​(b,:)T​
并每个VU选出前K个与自己最相似的VU，作为邻接VU，双方的偏好一定程度上能相互反映，
就是比较相似吧。

3) Interested Contents

该部分做的是将那些与其邻接的VU的rating矩阵重新构成一个新的评分矩阵H_K
应该可以理解为从最开所有评分矩阵R中，提取与自己最相似的那些VU的评分矩阵出来

然后可以认为矩阵中那些有评分（即非零）的内容就为其感兴趣的内容

再选出F_C个最好的内容作为预测的感兴趣的内容上传到本地RSU。（F_C应该是数量）

4) Popular Contents

本地RSU对所有车辆上传的内容进行比较，也是选出F_C个内容作为受欢迎的内容。
此处选出的内容不再是感兴趣的内容（个人），而是受欢迎的内容（群体）。

C. Cooperative Caching Based on DRL

1) DRL Framework

包括三个部分
a) State
s(t) = (s₁; s₂; : : : ; s_c）对F_C个内容进行排序的集合

b) Action
用 a(t）的0/1值表示是否对更新本地存储内容
具体来说

• a(t) = 1 时
  本地RSU从F_c中选出n个内容，并与现存较低排名的内容进行交换。形成新的状态s(t + 1）;
  邻近RSU则是根据F_C中不属于s(t + 1)中的c个内容进行存储
• a(t) = 0 时
  本地RSU不会进行存储内容变化；
  邻近RSU的存储方式与 = 0一样。

c) Reward
用r(t)函数表述该时段，所有车辆请求内容的延迟
由于内容的存放的位置不同，产生的延迟有三种：直接在本地RSU，在附近RSU，在MBS。延迟计算就是 d = s / R = 内容大小 / 速率

具体计算如下：
在本地RSU ： d R , i , f r = s R R , i r , d_{R,i,f}^r =\dfrac{s}{R_{R,i}^r}, dR,i,fr​=RR,ir​s​,
在附近RSU： d ˉ R , i , f r = s R R , i r + s R R − R \bar{d}^r_{R,i,f} = \dfrac{s}{R^r_{R,i}} + \dfrac{s}{R_{R-R}} dˉR,i,fr​=RR,ir​s​+RR−R​s​
在MBS： d B , i , f r = s R B , i r d^r_{B,i,f} = \dfrac{s}{R^r_{B,i}} dB,i,fr​=RB,ir​s​
然后给每种情况下的产生的延迟一个类似权值的 λ \lambda λ产生一辆车V_i单个内容f的延迟计算r(t)：
r i , f r ( t ) = { e − λ 1 d H , i , f f ∈ s ( t ) e − ( λ 1 d R , i , f r + λ 2 d ⃗ R , i , f ) f ∈ s n ( t ) e − λ 3 d M , i , f r f ∉ s ( t ) and f ∉ s n ( t ) r_{i,f}^{r}(t)=\begin{cases}e^{-\lambda_1d_{H,i,f}}&f\in s(t)\\[1ex]e^{-\left(\lambda_1d_{R,i,f}^{r}+\lambda_2\vec{d}_{R,i,f}\right)}&f\in s_n(t)\\[2ex]e^{-\lambda_3d_{M,i,f}^r}&f\not\in s(t)\text{and}f\not\in s_n(t)\end{cases} ri,fr​(t)=⎩ ⎨ ⎧​e−λ1​dH,i,f​e−(λ1​dR,i,fr​+λ2​d R,i,f​)e−λ3​dM,i,fr​​f∈s(t)f∈sn​(t)f∈s(t)andf∈sn​(t)​
合并所有车辆的传输延迟得到： r ( t ) = ∑ i = 1 N r ∑ f = 1 F i r r i , f r ( t ) r(t)=\sum_{i=1}^{N^r}\sum_{f=1}^{F_i^r}r^r_{i,f}(t) r(t)=∑i=1Nr​∑f=1Fir​​ri,fr​(t)

2) DRL Algorithm

**要先了解DQN算法，**主要的思想是： y i = r i + γ D max ⁡ a ∈ { 0 , 1 } Q ′ ( s i , a ; θ ′ ) y^i=r^i+\gamma_D\max\limits_{a\in\{0,1\}}Q'(s^i,a;\theta') yi=ri+γD​a∈{0,1}max​Q′(si,a;θ′) ， L ( θ ) = 1 I ∑ i = 1 I [ ( y i − Q ( s i , a i , θ ) ) 2 ] L(\theta)=\dfrac{1}{I}\sum_{i=1}^I\left[(y^i-Q(s^i,a^i,\theta))^2\right] L(θ)=I1​∑i=1I​[(yi−Q(si,ai,θ))2]，得到损失函数，对θ梯度下降，然后更新θ。

• 补充Q-learning算法

=1001.2014.3001.5506

• 补充MDP问题

• 补充 DQN 算法：

DQN（Deep Q-Network）算法是一种深度强化学习算法，旨在通过学习价值函数来解决强化学习中的控制问题。基于Q-learning算法，通过使用深度神经网络来逼近Q值函数，从而能够在更复杂的环境中处理高维度状态空间和行动空间。具体而言，DQN算法通过以下步骤进行学习：
1、神经网络输入状态信息，输出每个动作的Q值；
2、采用ε-greedy等方法选择动作；
3、执行动作，观察新的状态和奖励；
4、将新的状态和奖励存储到replay buffer中；
5、从replay buffer中随机抽取一批经验样本，并利用样本更新神经网络的参数；
6、重复以上步骤，直到达到预设的终止条件。

DQN算法的核心是使用深度神经网络来逼近Q值函数，通过反向传播算法来优化网络参数，使得网络输出的Q值能够更加准确地估计每个动作的价值。同时，DQN算法使用replay buffer来存储历史经验样本，通过随机抽样来减小数据的相关性和偏差，提高学习效果。DQN算法在各种强化学习问题上都有着良好的表现，如Atari游戏、机器人控制、自动驾驶等。

该部分从DQN算法开始讲，他把Q值分成 V状态值函数 和 A动作优势函数 来计算。
为了得到较好的动作函数值，首先把RSU把s(t) 作为预测网络的输入，生成V (s(t); θ) 和A(s(t); a; θ) 。同时为了减少Q(s(t); a; θ) 取值范围，减去了一个平均A 具体如下：往后就适合DQN算法一样了，他就是把Q值函数变成了 V 和 A，然后用目标和预测构造损失函数，使用梯度下降。

后面的部分是一些实验对比

本文标签： Mobility