2

我目前正在研究强化学习中著名的山地车问题。这个问题具有连续性，这意味着我有两个变量：一个位置 - 从 -1.2 到 0.5 和速度 - 从 -0.07 到 0.07。我有 3 种可能的动作 - 反向加速、向前加速和空档，动作会导致在适当方向上改变位置。由于如何计算加速度，我的位置变量是连续的，这意味着我不能使用查找表，所以我尝试将位置速度轴划分为矩形扇区，将位置划分为宽度为 0.05 的桶，将速度划分为长度为 0.005 的桶，为每个部门分配一个索引，我是这样做的：

public int discretiseObservation(Observation observation) {
    double position = observation.getDouble(0) ;
    double velocity = observation.getDouble(1);

    boolean positionNegativeFlag = position < 0;
    boolean velocityNegativeFlag = velocity < 0;

    double absolutePosition = Math.abs(position);
    double absoluteVelocity = Math.abs(velocity);

    double discretePosition = Math.floor(absolutePosition / 0.05);
    double discreteVelocity = Math.floor(absoluteVelocity / 0.005);

    if(velocityNegativeFlag) {
        discreteVelocity += 14;
    }

    if(positionNegativeFlag) {
        discretePosition += 10;
    }

    return (int)discretePosition * 28 + (int)discreteVelocity;
}

但是这种方案会导致某些扇区具有相同的索引号。您知道如何离散这两个连续变量吗？

更新：抱歉忘了提到当位置或速度超过最大值或最小值时，我将其设置回最大值或最小值

4

2 回答 2

2

所有这些签名检查都使事情变得过于复杂。另外，你应该避免使用魔法常量——给它们起有意义的名字。离散化代码应如下所示：

double normalize(double value, double min, double max) {
    return (value - min) / (max - min);
}

int clamp(int value, int min, int max) {
    if (value < min) value = min;
    if (value > max) value = max;
    return value;
}

int discretize(double value, double min, double max, int binCount) {
    int discreteValue = (int) (binCount * normalize(value, min, max));
    return clamp(discreteValue, 0, binCount - 1);
}

public int discretizeObservation(Observation observation ) {
    int position = discretize(observation.getDouble(0), minPosition, maxPosition, positionBinCount);
    int velocity = discretize(observation.getDouble(1), minVelocity, maxVelocity, velocityBinCount);
    return position * velocityBinCount + velocity;
}
于 2012-05-30T12:29:21.253 回答
0

你没有限制你的位置和速度。当它们太大时（无论是什么符号），它们都会溢出硬编码的偏移值（14 和 10）。在组合它们之前，您必须限制这些值。

于 2012-05-29T04:48:17.510 回答