论文阅读笔记：Game theoretic self-organization in multi-satellite distributed task allocation

鼠鼠今天看论文了嘛

已于 2023-12-07 14:01:38 修改

阅读量1k

点赞数 18

分类专栏：学习笔记卫星任务规划文章标签：论文阅读笔记

于 2023-12-02 22:18:33 首次发布

本文链接：https://blog.csdn.net/qq_41650543/article/details/134715678

版权

学习笔记同时被 2 个专栏收录

7 篇文章 1 订阅

订阅专栏

卫星任务规划

3 篇文章 2 订阅

订阅专栏

前言

本文介绍了一种基于博弈学习的分布式卫星任务规划

摘要

将多卫星系统中的自组织任务分配作为一种潜在的博弈，提出了一种分布式任务分配算法（DT2A）问题。
证明了博弈的每个纳什均衡构成了一个任务覆盖，使执行任务的数量最大化。

此外，我们还证明了所提出的DT2A在有限时间内以概率收敛到接近最优赋值。数值实验证明了该算法对偶然干扰的鲁棒性，并揭示了内存长度对求解效率细化的积极影响。在小规模和大规模场景下的比较实验突出了所提出的方法优于现有的分布式或集中的典型方法。

问题建模

多卫星任务分配

考虑一个地球观测星座，它由一组卫星 $S=\{s_i|i∈N\}$ 组成，其中 $N = \{1,2，...，n\}$ 。每个 $s_i$ 都是由其绕飞行轨道 $o_i$ ，观察类别(光学或雷达)、摇摆范围、存储容量以及两个相邻任务实现之间的最短时间间隔。用
$R =\{r_j| j∈M\}$ 、 $M = \{1,2，...，m\}$ 表示客户端请求集，每个 $r_j$ 是与一个观察类别、要观察的网格区域和最小存储要求相关联的元任务。
对于 $s_i$ ，表示其由 $A_i^f$ 设置的可行任务，它由位于其关注范围（FOR）内的任务组成可以独立完成。
为了考虑执行效率，一个给定的 $s_i$ 的可行任务集被视为一个唯一的任务序列，按照与 $s_i$ 相遇的时间顺序执行。

如图1所示，{r2、r3、r4}表示 $s_i$ 的r4→r2→r3的任务序列。如果对应的任务序列 $r_{i_1}$ → $r_{i_2}$ →…→ $r_{i_{n_i}}$ ，则定义 $s_i$ 的可行分配 $a_i$ 不违反操作约束，可行分配集用 $A_i$ 表示。

为了考虑执行效率，一个给定的si的可行任务集被视为一个唯一的任务序列，按照与si相遇的时间顺序执行。如图1所示，{r2、r3、r4}为si的r4→r2→r3的任务序列。如果对应的任务序列 $r_{i_1}$ → $r_{i_2}$ → $r_{i_3}$ →… $A_i$ 的可行分配rini不违反操作约束，可行分配集用 $A_i$ 表示。因此，任务分配空间用 $\prod_{i=1}^n A_i$ 表示，其中一个 ${a_1，a_2，...，a_n\}$ 是对所有卫星的可行分配的组合。

为了简单的理论分析，我们假设

当且仅当卫星有共同的可执行任务时，可通过星间链路通讯。据此，定义s的邻域为 $\Omega_i = \{s_j|A_i^f ∩ A_j^f \neq\varnothing \}$

观测成本 $OC_i(a_i)$ 和卫星运行侧摆成本 $SC_i(a_i)$ 共同构成了运行成本：
$f(a_i) = OC_i(a_i) + SC_i(a_i)= \sum_{j=1}^{n_i}\{c_i(r_{ij})+\lambda_i|\theta_{ij} - \theta_{i,j-1}|\}$
其中， $c_i(r_{ij})$ 是 $s_i$ 观测 $r_{ij}$ 的成本， $c_i(r_{ij})$
对于每个 $s_i$

多卫星任务分配的目的是找到使总成本最小化的最优任务覆盖范围。在数学上，它可以表述为一个无约束最小化问题，其全局目标函数定义为
$F(a)=\sum_{i=1}^{n}f_i(a_i) + \sum_{j}^{m}[1 − b_j(a)]\omega_j$
其中的第二部分是通过任务优先级权重 $\omega_j$ 对任何未响应的请求 $r_j$ 进行惩罚。具体来说， $b_j = 0$ 表示没有卫星选择任务 $r_j$ ，而 $b_j = 1$ 表示选择。

等效性分析

证明了F (a)的最优解与最优任务覆盖度之间的等价性。

定义 $T_0(a) = \{r_j|b_j(a) = 0,j∈M\}$ 组成的未分配任务集
定理一：
.如果 $\forall j \in M$ ， $ω_j>max_i∈N_f(A_i^f)$ ，则(2)的最优解必须是使总成本最小化的最优任务覆盖。

定理二：

网络势博弈

针对多卫星任务分配中的自组织问题，我们将网络博弈 $G=(S,{A_i},{U_i})$ 视为一个自主和理性的参与者。
从博弈论的角度来看，一个可行的任务分配 $a_i∈A_i$ 被定义为一个动作，而每个任务分配的profile一个 $a \in A$ 被称为联合动作（a joint action）。
为了使局部效益 $U_i$ 最大化，每个玩家 $s_i$ 仅基于 $i$ 中的邻域信息从其动作集 $A_i$ 中迭代地选择其动作。
对于基于竞争博弈论的分布式协调和优化，纳什均衡、潜在博弈等定义的概念起着重要的作用，以下为相关的定义：

定义1（纳什均衡）：对于有限策略博弈 $G=(S,{A_i},{U_i})$ ，一个联合行动 $a \in A$ 被称为纳什均衡，如果任何参与者不能从单边偏离当前行动 $a_i$ 中获益
$∀i∈N,U_i(a_i,a_{−i})=max_{\widetilde{a}_i∈A_i}U_i(\widetilde{a}_i,a_{−i})$

定义2（潜在博弈）：一个（精确的）潜在博弈被一个有限策略博弈 $G=(S,{A_i},{U_i})$ 去定义，如果存在一些潜在函数 $φ:A→\mathbb{R}$ ，
$U_i(\widetilde{a}_i,a_{−i})−U_i(a_i,a_{−i})=φ(\widetilde{a}_i,a_{−i})−φ(a_i,a_{−i})$ 适用于每一个 $i \in N$ ，每一个 $\in a$ ，和每一个动作 $\widetilde{a}∈A_i$

定义3（convention）：表示从迭代t + 1−l到t的联合动作序列（在+1−l，在+2−l，…，at）。
如果每个元素都是相同的纳什均衡a，那么 $h_l^t$ 被称为convention。通过使用wonderful-life utility(具体参考论文XX )将系统级目标F(a)分解为每个个体，我们建立了以下潜在的博弈。

定理2
任务分配博弈 $G=(S,{A_i},{U_i})$ 是一个潜在的博弈，如果选择潜在函数 $φ (a)$ 和局部收益 $U_i(a)$ 为
$\phi(a)=-F(a)$
$U_i(a)=-f(a_i)-\sum_{k∈\mathcal{U}_i(a)}\omega_k$
其中 $U_i(a) = A_i^f∩T_0(a)$ 是对 $s_i$ 可行的未分配任务集

利用势博弈，其中势函数的优化器必须是纳什均衡，分布式任务分配问题可以通过获得纳什均衡并尽可能将其细化为全局最优性。
注意，由于 $ω_j$ 可以设置为任意大的整数，因此不需要全局信息来保证定理1的满足

定理3对于任务分配博弈 $G=(S,{A_i},{U_i})$ ，每个纳什均衡 $a \in A$ 必须是一个没有重复分配任务的任务覆盖。

算法设计

3.1.分布式任务分配算法（DT2A）
算法伪代码

**Require：**卫星集 $S$ 、客户端请求 $R$ 、观测成本、目标角度、成本系数 $λ_i$ 、任务
优先级权重 $ω_i$ 、内存长度 $l$ ；
**Ensure：**任务覆盖的方案随机初始化一个1和 $M^1$
对于每个迭代 $t = 1, 2, ...$ ，执行
对于每个卫星 $s_i∈S$ ，同步地执行
$a_i^t$ 与邻域交换信息；
计算 $U_i$ ， $B_i^t$ ， $R_i^t$ ；
$R_i^t$ 与邻域交换信息；
检查它是否是一个innovater；
计算 $β_i^t$ 并更新 $M_i^t$ ；
随机更新到 $a_i^{t+1}$ ；
结束循环
结束循环

为了平衡解决效率和收敛速度，我们通过给每个玩家分配一个大小为 $l$ 的有限内存来引入随机性。具体来说，第t次迭代中的内存向量用 $M_i^t =(v_1,v_2,...,v_l),a_i∈A_i$ 表示，内存配置文件用 $M_t = \{M_1^t，M_2^t，...，M_n^t\}$ 表示。对于在地面上生成的一组给定请求R，我们假设一个广播机制，通过该机制所有卫星都可以被告知完整的任务集。在此基础上，每个si计算其可行任务集Ai f，并得到可行分配集Ai。

为了启动分布式任务分配，每个卫星从 $A_i$ 中随机选择在=1i和Mt=1 i初始化。在此之后，主要的协调过程以一种同步的方式实现。
在每次迭代t中，玩家只在i处与他们的邻域在i中交换当前的动作信息，基于(6)中的局部效用 $U_i^t$ 、最佳响应 $B_i^t$ 和遗憾值 $R_i^t$ 来计算

$B_i^t = \mathop{\arg\max} \limits_{\widetilde{a}_i∈A_i}U_i(a_i^t,a_{-i}^t)$
$R_i^t = U_i(B_i^t,a_{-i}^t) - U_i(a_i^t,a_{-i}^t)$

用 $R_i^{t*}=max_{j∈\Omega_i}R_j^t$ 表示i中的最大遗憾值，ID编号用 $min(\mathop{\arg\max} \limits_{\widetilde{a}_i∈A_i}R_j^t)$

如果同时满足以下两个条件，si将被定义为innovator：
(1)它在 $\Omega_i$ 中有最大的正遗憾值，
即 $R_i^t>0,R_i^t>R_j^t,∀s_j∈\Omega_i$
(2)任何 $j < i$ 的邻域 $∀s_j∈\Omega_i$
$j<i,R_j^t<R_i^t$

否则， $s_i$ 就会被称为普通player。对于innovator，在任何给定的邻域i中，最多有一个创新者参与者。

仿真结果

为了评估DT2A在多卫星自组织任务分配中的有效性，并证明其与现有方法的优越性，本节通过蒙特卡罗模拟平均100多个独立运行的数值结果。

纳什均衡的生成和细化

首先，我们考虑一组n个=5个成像卫星，其地面轨迹如图2所示。
每颗卫星都配备了一个光学摄像机，用于收集地面信息，侧向摇摆范围为±25◦，摇摆成本系数为 $λ_i = 10$ 。为了验证我们的方法在纳什均衡解生成和细化中的有效性，在重叠区域生成了一组= 10
任务:
(1)经度120W-60W和纬度30N-60N；
(2)经度30W-30E和纬度60S- 30S；
(3)经度60E-120E和30N-60N。
由于本文关注的是分布式协调机制，因此由矩阵 $C_{n×m}$ 和 $D_{n×m}$ 给出了可行集，每个 $c_{ij}$ 和 $d_{ij}$ 表示 $s_i$ 执行 $r_j$ 时的观测代价和目标摇摆角
观测成本矩阵
目标摆角
在 $C_1$ 和 $D_1$ ，它需要 $s_2$ 的成本 $c_{26} = 74$ 观察第6个网格摇摆角 $d_{26}=15d°$ ，而 $c_{43} =∞$ , $d_{43} =∞$ 表明 $r_3$ 是一个不可执行的任务。据此，相关网格区域位于 $s_4$ 的。因此，得到了 $s_2$ 和 $s_4$ 的可行集，分别为 $A_2^f = \{r_j| j = 1、2、5、6、7、8\}$ 和 $A_4^f = \{r_j| j = 2、4、5、6、7、9、10\}$ 。假设 $A_i^f$ 的每个子集都有一个满足操作约束的可行分配，分配轮廓空间a的基数为 $A| = {2^{30}}≈109$ 。

参考了基于博弈学习的分布式卫星任务规划

实验

假设有5个卫星和10组任务，则设C和D为5*10的矩阵

有矩阵
C：
$\begin{bmatrix} 36&3&33&0&33&0&70&0&0&0 \\ 39 & 64 & 67 & 97 & 0 & 84& 0 & 22& 0& 0 \\ 0& 0& 73 & 72 & 0& 0& 0& 0& 93& 83\\ 0& 0& 0& 0& 49& 28& 0& 0& 80& 14\\ 0& 0& 0& 0& 0& 32& 21& 0& 0& 62\ \end{bmatrix}$
卫星星执行任务载荷能量消耗矩阵，0表示无法执行该任务

D：
$\begin{bmatrix} -14&-6&-4&0&13&0&-19&0&0&0 \\ -20& -21& -11 & 15 & 0 & -1& 0 &-11& 0& 0 \\ 0& 0& 17 & 21& 0& 0& 0& 0& -15& 13\\ 0& 0& 0& 0& 17& 19& 0& 0& 18& 2\\ 0& 0& 0& 0& 0& 4 & 24& 0& 0&11\ \end{bmatrix}$
卫星执行任务侧摆角度 0表示无法执行该任务

FT：需要执行的任务数量，和每个任务的编号
从上到下分别为每个卫星能够执行的任务编号

$\begin{bmatrix} 5&1&2&3&5&7&0&0&0&0 \\ 6& 1& 2&3&4&6&8 &0& 0& 0 \\ 4& 3& 4& 9& 10& 0& 0& 0& 0& 0\\ 4& 5& 6& 9& 10& 0& 0& 0& 0& 0\\ 3& 6& 7& 10& 0& 0& 0& 0& 0&0\ \end{bmatrix}$

完整策略是由{-1,0,1}组成的一个M行1列的矩阵，-1表示无法完成此任务，1表示执行此任务，0表示不执行此任务
$\begin{bmatrix} 1&1&0&-1&0&-1&1&-1&-1&-1\\ 0& 0& 1&1&-1&0&-1&1& -1& -1\\ -1& -1& 0& 0& -1& -1& -1& -1& 1& 1\\ -1& -1& -1& -1& 1& 1& -1& -1& 0 &0\\ -1& -1& -1& -1& -1& 1& 0& -1& -1&0\ \end{bmatrix}$

方法

constexpr int MEMORY_LENGTH = 13; // 存储器长度
constexpr int TMAX = 16; // 最大迭代步数
constexpr int M = 10; // 客户端请求数量
constexpr int N = 5; // 卫星数量
constexpr double SWAY_COEFF = 10; // 侧摆代价效率
constexpr double UNCOVER_WEIGHT = 1000; // 未执行任务的惩罚系数
double ccost; // 当前任务总代价
double regret; // 遗憾值
Mat matC; // 每个任务的观测代价
Mat matD; // 每个任务的侧摆角
vector<uint32_t> feasibleStrategy; // 每个卫星的可执行策略编号
下列数据为按位运算变量，从高位开始
uint32_t csid, nsid, bestsid; // 当前策略编号，下一个策略编号，局部最优策略编号
uint32_t cstrategy; // 当前执行策略，1表示执行此任务，0表示不执行此任务
uint32_t neighbor=0; // 每个卫星的邻居集
uint32_t feasibleTask=0; // 每个卫星的可执行任务编号

SID_to_ImplementStrategy：根据策略编号计算执行策略
TotalStrategy_to_SID：计算策略编号
Strategy_Cost：计算当前个体采取给定执行策略的任务总代价
CountSetBits：计算执行了任务的收益

    srand(time(0));
    matC  // 卫星执行任务载荷能量消耗矩阵 0表示无法执行该任务
    matD // 卫星执行任务侧摆角度 0表示无法执行该任务
    matFT// 需要执行的任务数量，和每个任务的编号
    matNeighbor // 每个卫星的邻居数量，和每个邻居的编号
    Agent stlt[N];  // N个卫星(satellite)
    S; //随机的策略
    matdata;  // 临时数据
    int intdata;  // 临时数据
    uint32_t task;  // 一组任务的标志位
    uint32_t ims;  // 执行策略
    double cost, cost1, cost2;  // 总收益，执行了任务的收益，个体的代价
    double maxvalue; uint32_t maxvaluei;  // 最大值和最大值索引


    //主要的函数如下
    uint32_t NE;  // 达到纳什均衡的个体数量
    for (int t = 0; t < TMAX; t++) {  // 分布式协调
        NE = 0;
        for (int i = 0; i < N; i++) {  // 每个个体计算当前最优策略
            task = 0;
            for (int j = 0; j < N; j++)  // 计算个体的所有邻居执行策略后的未覆盖任务
                if (stlt[i].neighbor & (1 << (N-1-j)))  // 是当前个体的邻居
                    task |= stlt[j].cstrategy;  // 每个邻居个体依次执行自己的策略并更新任务标志位
            task ^= (1<<M) - 1;  // 将任务标志位取反表示尚未执行的任务
            task &= stlt[i].feasibleTask;  // 尚未执行并且可以由当前个体执行的任务
            maxvalue = 0;
            if (task) {  // 当存在可执行的任务时，求当前最优策略
                for (uint32_t j: stlt[i].feasibleStrategy) {  // 在可执行任务中选择收益最大的任务
                    ims = stlt[i].SID_to_ImplementStrategy(j);  // 根据策略编号计算执行策略
                    cost1 = UNCOVER_WEIGHT * CountSetBits(task & ims);  // 执行了任务的收益
                    cost2 = stlt[i].Strategy_Cost(ims);  // 个体的代价
                    cost = cost1 - cost2;  // 每个策略的总收益
                    if (cost > maxvalue)  // 求最优策略的代价值和编号
                        { maxvalue = cost; maxvaluei = j; }
                }
                stlt[i].bestsid = maxvaluei;  // 局部最优策略
            }
            else  // 当没有可执行的任务时，最优策略为0
                stlt[i].bestsid = 0;
            cost1 = UNCOVER_WEIGHT * CountSetBits(task & stlt[i].cstrategy);
            cost2 = stlt[i].Strategy_Cost(stlt[i].cstrategy);
            cost = cost1 - cost2;  // 计算当前策略的收益
            stlt[i].regret = maxvalue - cost;  // 计算遗憾值
            if (stlt[i].regret == 0)  // 0表示达到纳什均衡
                NE++;
            else if (stlt[i].regret < 0)
                cout << "regret error!" << endl;
        }

        maxvalue = 0;
        for (int i = 0; i < N; i++) {  // 计算所有个体中的最大遗憾值
            if (stlt[i].regret > maxvalue)
                { maxvalue = stlt[i].regret; maxvaluei = i; }
        }
        for (int i = 0; i < N; i++) {  // 每个个体更新策略
            if (maxvalue == 0)
                stlt[i].nsid = stlt[i].csid;
            else if (i == maxvaluei)
                stlt[i].nsid = stlt[i].bestsid;
            else
                stlt[i].nsid = stlt[i].csid;
            stlt[i].Update();
        }
        if (NE == N)  // 所有个体都达到了纳什均衡
            break;
    }

    task = 0;
    for (int j = 0; j < N; j++) {
        ims = stlt[j].SID_to_ImplementStrategy(stlt[j].nsid);
        stlt[j].ccost = stlt[j].Strategy_Cost(ims);//更新当前任务总代价
        task |= ims;
    }
    cout << Global_Fit(stlt, task) << endl;
    for (int i = 0; i < N; i++)
        cout << stlt[i].nsid << endl;
    return 0;
}

鼠鼠今天看论文了嘛

关注

18
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
论文阅读笔记：Game theoretic self-organization in multi-satellite distributed task allocation

本文将多卫星系统中的自组织任务分配作为一种潜在的博弈，提出了一种分布式任务分配算法（DT2A）问题。我们证明了博弈的每个纳什均衡构成了一个任务覆盖，使执行任务的数量最大化。此外，我们还证明了所提出的DT2A在有限时间内以概率收敛到接近最优赋值。数值实验证明了该算法对偶然干扰的鲁棒性，并揭示了内存长度对求解效率细化的积极影响。在小规模和大规模场景下的比较实验突出了所提出的方法优于现有的分布式或集中的典型方法。
复制链接

扫一扫

专栏目录