Java 前馈神经网络训练

我正在尝试编写前馈神经网络，我正在测试它，用粒子群优化学习x*y函数（PSO算法正在工作），但它甚至无法接近学习函数。我已经看过我的代码很多次了，所以我不知道我是否只是对NN算法中的任何明显错误视而不见

架构是一个int[]和{No'输入、No'隐藏神经元、No'输出} 这里我用{2,3,1}表示x*y

注-为输入层和隐藏层中的偏差添加了神经元0。激活函数为tanh（）

//接受输入数组和权重向量w
公共浮点[]求解（浮点[]输入，浮点[]w）{
int max_=0；
对于（inti=0；imax_神经元？此结构[i]：max_神经元；
}
//层输出阵列
float[]输出=新的float[max_neurons+1]；//+1用于偏置神经元0
float[]输出=新的float[max_+1]；
输出[0]=1；//设置偏差
输出_l[0]=1；//设置偏差
//从输入设置
对于（int i=0；i第一件也是最重要的事情，无论您如何编码，前馈多层神经网络都不会学习x*y，尤其是当数据以两个连续输入的形式呈现时。原因：1）.x*y输出是无界的，正常MLP不适合学习此类函数。在给定适当规范化的数据2）的情况下，它最多只能近似于x*y的某个固定范围。为了正确地学习乘法，应该将数字表示为二进制（每个输入神经元一个数字）。有关使用NNs进行算术运算的进一步讨论，请参阅

结论：对于调试新实现的神经网络，x*y是一个非常糟糕的选择。考虑使用逻辑门，如，和，或，或XOR代替。 我的想法是，根据普遍逼近定理，我应该能够逼近函数f（x，y）=xy，因为最后我将用它来逼近更复杂的函数。@SamPalmer普遍逼近定理表明MLP可以逼近实坐标空间紧致子集上的任何函数。输出f（x，y）=x*y不是实数的紧致子集（它是无界的），因此一般来说，普适逼近定理在这里不适用。因此，MLP只能在x和y的某个有限范围内近似x*y。此外，在实践中，某些数据表示方法会使学习变得特别困难。
//takes in array of inputs, and weight vector w
public float[] solve(float[] input, float[] w){

    int max_neurons = 0;
    for(int i =0; i<this.architecture.length; i++){
        max_neurons = this.architecture[i]>max_neurons? this.architecture[i]:max_neurons;
    }
    //layer output arrays
    float[] output = new float[max_neurons+1]; //+1 for bias neuron 0
    float[] output_l = new float[max_neurons+1];
    output[0] = 1; //set bias
    output_l[0] = 1; //set bias
    //setup from input
    for(int i = 0; i<architecture[0]; i++){
        output[i+1] = input[i];

    }
    //iterate through hidden layers
    int hidden_layers = architecture.length-2;
    int vector_index = 0;
    float av = 0;
    for(int l = 1; l<=hidden_layers; l++){
        for(int n = 1; n<=architecture[l]; n++){
            av = 0;
            for(int k = 0; k<=architecture[l-1]; k++){
                av += output[k]*w[vector_index];
                vector_index++;
            }
            output_l[n] = af.activation(av);
        }
        output = Arrays.copyOf(output_l, output_l.length);
    }

    //output layer no activation function
    int l = architecture.length-1;
    for(int n = 0; n<architecture[l]; n++){
        av = 0;
        for(int k = 0; k<=architecture[l-1]; k++){
            av += output[k]*w[vector_index];
            vector_index++;
        }
        output_l[n] = av;
    }
    return Arrays.copyOf(output_l, output_l.length);
}