Question

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

当代理选择下一步时，将调用 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;
}

我使用this link作为指导。我为ALPHA＆amp;尝试了不同的值。 BETA，隐藏神经元的数量。资格跟踪初始化为0.

Answer 1

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

当我们一起使用TD和NN时会发生这种情况。这发生在我之前，我搜索了很长时间。我学到的教训如下：

根据Richard Sutton的说法：除非你知道完全如何调整神经网络，否则不要尝试将神经网络用作函数逼近器和TD方法。否则，这将导致很多问题。

要了解更多有关它的信息，请查看Sutton在youtube上的演讲。

Java中时态差异学习的实现

1 个答案: