边缘计算卸载算法--CD梯度下降

梯度下降卸载算法

背景：我实现该算法是在边缘计算单个工作流任务环境中，下面可以看到此背景下的java代码实现。
此处假设我们的工作流任务中只有3个任务节点（构成一个有向无环图），下面基于此假设分析算法。

1. 算法伪代码

2.输入

假设初始化卸载策略{1，0，0} // 0:不卸载 1:卸载

3.输出

假设局部最优卸载策略{0，0，0}

4.算法中参数说明

5.例子

说明：
① 工作流任务数假设为3个。
② 一个卸载策略表示为0、1组成的长度为3的数组，比如{1，1，0}表示第一、二个任务卸载、第三个任务不卸载。

核心思想：

1. 初始化一个卸载策略：{1，1，1}。
2. 第一轮循环时：
   ① 保持第一个任务卸载策略不变{1，1，1}，其他依次变化{1，0，1}、{1，1，0}；
   ② 计算卸载策略的优化目标值依次为a1、a2、a3；
   ③ 比较 a1 a2 a3, 如果a2的优化目标值最小，小于初始化目标值也为默认当前最优目标值 a1(优化目标值越小越好)，则更新卸载策略数组为{1，0，1}，此时的优化目标值a2为目前的最优优化目标值。
3. 继续进行循环，和②一样，保持第二个任务不变，{1，0，1}，{0，0，1}，{1，0，0}，计算它们的目标值再进行比较，如果有更小的目标值，则继续下一轮的循环。
4. 如果a1的优化目标值最小（也就是本次循环优化目标值并没有减小），那么当前最小优化目标值对应的卸载策略为局部最优卸载策略结束算法。

6.我的java代码实现

① 初始化

/**
 * 初始化梯度下降任务卸载与否的数组
 * @param taskNum 任务总数
 */
public void coordinateDescentInit(int taskNum){
    // 卸载策略初始化
    oldStrategy = new ArrayList<>();
    int count = 0;
    for (int i = 0; i < taskNum; i++) {
        int[] offloadStra = new int[taskNum];
        for (int j = 0; j < taskNum; j++) {
            offloadStra[j] = 0;
        }
        offloadStra[count] = 1;
        oldStrategy.add(offloadStra);
        ++count;
    }
    //oldStrategy.get(0)[0] = 0;

    // 目标值初始化
    obj = new double[taskNum];
    for (int i = 0; i < taskNum; i++) {
        obj[i] = 0;
    }
    minObj = Double.MAX_VALUE;

    // 其他变量初始化
    index = 0;
    u = 0;
    updateFlag = true;

}

② 更新卸载策略

/**
 * 更新卸载策略集合
 */
void coordinateDescentUpdate(){
    // 找出所有卸载策略中最小优化目标值minObj,卸载策略下标index
    double minObj1 = minObj;
    int index1 = index;
    for (int i = 0; i < taskNum; i++) {
        if(obj[i] < minObj1){
            minObj1 = obj[i];
            index1 = i;
        }
    }
    // 判断优化目标是否减小
    if(minObj1<minObj && u<taskNum){
        updateFlag = true;
        minObj = minObj1;
        index = index1;
    }else{
        updateFlag = false;
    }
    if(updateFlag){
        int[] offloadStra = new int[taskNum];// 上一次迭代最优卸载策略
        for (int i = 0; i < taskNum; i++) {
            offloadStra[i] = oldStrategy.get(index)[i];
        }
        oldStrategy.removeAll(oldStrategy);// 清空卸载策略集合
        oldStrategy.add(offloadStra);
        index = 0;
        for (int i = 0; i < taskNum; i++) {
            if(i != u){
                int j;
                int[] temp = new int[taskNum];
                for (j = 0; j < taskNum; j++) {
                    temp[j] = offloadStra[j];
                }
                temp[i] = (temp[i]+1) % 2;
                oldStrategy.add(temp);
            }
        }
        // 清空obj数组
        for (int i = 0; i < taskNum; i++) {
            obj[i] = 0;
        }
    }
}