0

下面的代码是我对时间差异学习的实现。使用 TD 算法的代理与使用 mini-max 程序玩游戏的代理玩了超过 750,000 场游戏，但问题是 TD-agent 不学习......这个实现有什么问题？

当代理选择下一步动作时调用 updateToNextState。

public void updateToNextState(int[] currentState, double[] nextStateOutput) {
    double[] outputOfNext = nextStateOutput;
    double[] outputOfCurrent = getOutput(currentState);
    double[] error = getDifferenceOfOutputs(outputOfNext, outputOfCurrent);

    lastHandledState = currentState;

    for (int j = 0; j < layers[HIDDEN].neurons.length; j++) {

        for (int k = 0; k < layers[OUTPUT].neurons.length; k++) {

            double toBeUpdatedValueForJToK = BETA * error[k]
                    * eligibilityTraces.getEjk(j, k);
            layers[HIDDEN].neurons[j].updateWeightToNeuron(
                    layers[OUTPUT].neurons[k].getNeuronId(),
                    toBeUpdatedValueForJToK);

            for (int i = 0; i < layers[INPUT].neurons.length; i++) {

                double toBeUpdatedValueForIToJ = ALPHA * error[k]
                        * eligibilityTraces.getEijk(i, j, k);

                layers[INPUT].neurons[i].updateWeightToNeuron(
                        layers[HIDDEN].neurons[j].getNeuronId(),
                        toBeUpdatedValueForIToJ);

            }

        }
    }

    updateEligibilityTraces(currentState); 
 }



private void updateEligibilityTraces(int[] currentState) {
    // to ensure that the values in neurons are originated from current
    // state
    feedForward(currentState);
    for (int j = 0; j < layers[HIDDEN].neurons.length; j++) {
        for (int k = 0; k < layers[OUTPUT].neurons.length; k++) {

            double toBeUpdatedValueForJK = gradient(layers[OUTPUT].neurons[k])
                    * layers[HIDDEN].neurons[j].output;
            eligibilityTraces.updateEjk(j, k, toBeUpdatedValueForJK);
            for (int i = 0; i < layers[INPUT].neurons.length; i++) {
                double toBeUpdatedValueForIJK = gradient(layers[OUTPUT].neurons[k])
                        * gradient(layers[HIDDEN].neurons[j])
                        * layers[INPUT].neurons[i].output
                        * layers[HIDDEN].neurons[j]
                                .getWeightToNeuron(layers[OUTPUT].neurons[k]
                                        .getNeuronId());
                eligibilityTraces.updateEijk(i, j, k,
                        toBeUpdatedValueForIJK);
            }
        }
    }
}


 private double gradient(Neuron neuron) {
    return neuron.output * (1 - neuron.output);
}


  public void updateToNextWhenOpponentEndsGame(double[] outputOfEndState) {

    updateToNextState(lastHandledState, outputOfEndState);

}


    private double[] getDifferenceOfOutputs(double[] outputNext,
        double[] outputCurrent) {
    double[] differencesVector = new double[outputNext.length];

    for (int i = 0; i < outputNext.length; i++) {
        double difference = outputNext[i] - outputCurrent[i];
            differencesVector[i] = difference;

    }

    return differencesVector;
}

我已将此链接用作指导方针。我尝试了不同的 ALPHA 和 BETA 值，隐藏神经元的数量。资格跟踪初始化为 0。

4

1 回答 1

0

问题主要是你不能调整你的神经网络函数逼近器，从你所说的我可以假设“它不学习”，意味着算法不收敛。

当我们同时使用 TD 和 NN 时会发生这种情况。而我之前也遇到过这种情况，找了很久。我学到的教训如下：

根据 Richard Sutton 的说法：不要尝试将神经网络作为函数逼近器与 TD 方法一起使用，除非您确切知道如何调整您的神经网络。否则，这将导致很多问题。

要了解更多信息，请在 YouTube 上查找 Sutton 的演讲。

于 2015-06-17T13:04:44.090 回答