5

我正在尝试通过反向传播在 Java 中实现 FFNN，但不知道我做错了什么。当我在网络中只有一个神经元时它起作用了，但是我写了另一个类来处理更大的网络并且没有收敛。这似乎是数学中的一个问题——或者更确切地说是我的数学实现——但我已经检查了好几次，我找不到任何问题。这应该有效。
节点类：

package arr;

import util.ActivationFunction;
import util.Functions;

public class Node {
    public ActivationFunction f;
    public double output;
    public double error;

    private double sumInputs;
    private double sumErrors;
    public Node(){
        sumInputs = 0;
        sumErrors = 0;
        f = Functions.SIG;
        output = 0;
        error = 0;
    }
    public Node(ActivationFunction func){
        this();
        this.f = func;
    }

    public void addIW(double iw){
        sumInputs += iw;
    }
    public void addIW(double input, double weight){
        sumInputs += (input*weight);
    }
    public double calculateOut(){
        output = f.eval(sumInputs);
        return output;
    }

    public void addEW(double ew){
        sumErrors+=ew;
    }
    public void addEW(double error, double weight){
        sumErrors+=(error*weight);
    }
    public double calculateError(){
        error = sumErrors * f.deriv(sumInputs);
        return error;
    }   
    public void resetValues(){
        sumErrors = 0;
        sumInputs = 0;
    }
}

线路网络类：

package arr;
import util.Functions;

public class LineNetwork {
public double[][][] weights;    //layer of node to, # of node to, # of node from
public Node[][] nodes;          //layer, #
public double lc;
public LineNetwork(){
    weights = new double[2][][];
    weights[0] = new double[2][1];
    weights[1] = new double[1][3];
    initializeWeights();
    nodes = new Node[2][];
    nodes[0] = new Node[2];
    nodes[1] = new Node[1];
    initializeNodes();
    lc = 1;
}
private void initializeWeights(){
    for(double[][] layer: weights)
        for(double[] curNode: layer)
            for(int i=0; i<curNode.length; i++)
                curNode[i] = Math.random()/10;
}
private void initializeNodes(){
    for(Node[] layer: nodes)
        for(int i=0; i<layer.length; i++)
            layer[i] = new Node();
    nodes[nodes.length-1][0].f = Functions.HSF;
}
public double feedForward(double[] inputs) {
    for(int j=0; j<nodes[0].length; j++)
        nodes[0][j].addIW(inputs[j], weights[0][j][0]);
    double[] outputs = new double[nodes[0].length];
    for(int i=0; i<nodes[0].length; i++)
        outputs[i] = nodes[0][i].calculateOut();
    for(int l=1; l<nodes.length; l++){
        for(int i=0; i<nodes[l].length; i++){
            for(int j=0; j<nodes[l-1].length; j++)
                nodes[l][i].addIW(
                        outputs[j], 
                        weights[l][i][j]);
            nodes[l][i].addIW(weights[l][i][weights[l][i].length-1]);
        }
        outputs = new double[nodes[l].length];
        for(int i=0; i<nodes[l].length; i++)
            outputs[i] = nodes[l][i].calculateOut();
    }
    return outputs[0];
}

public void backpropagate(double[] inputs, double expected) {
    nodes[nodes.length-1][0].addEW(expected-nodes[nodes.length-1][0].output);
    for(int l=nodes.length-2; l>=0; l--){
        for(Node n: nodes[l+1])
            n.calculateError();
        for(int i=0; i<nodes[l].length; i++)
            for(int j=0; j<nodes[l+1].length; j++)
                nodes[l][i].addEW(nodes[l+1][j].error, weights[l+1][j][i]);
        for(int j=0; j<nodes[l+1].length; j++){
            for(int i=0; i<nodes[l].length; i++)
                weights[l+1][j][i] += nodes[l][i].output*lc*nodes[l+1][j].error;
            weights[l+1][j][nodes[l].length] += lc*nodes[l+1][j].error;
        }
    }
    for(int i=0; i<nodes[0].length; i++){
        weights[0][i][0] += inputs[i]*lc*nodes[0][i].calculateError();
    }
}
public double train(double[] inputs, double expected) {
    double r = feedForward(inputs);
    backpropagate(inputs, expected);
    return r;
}
public void resetValues() {
    for(Node[] layer: nodes)
        for(Node n: layer)
            n.resetValues();
}

public static void main(String[] args) {
    LineNetwork ln = new LineNetwork();
    System.out.println(str2d(ln.weights[0]));
    for(int i=0; i<10000; i++){
        double[] in = {Math.round(Math.random()),Math.round(Math.random())};
        int out = 0;
        if(in[1]==1 ^ in[0] ==1) out = 1;
        ln.resetValues();
        System.out.print(i+": {"+in[0]+", "+in[1]+"}: "+out+" ");
        System.out.println((int)ln.train(in, out));
    }
    System.out.println(str2d(ln.weights[0]));
}
private static String str2d(double[][] a){
    String str = "[";
    for(double[] arr: a)
        str = str + str1d(arr) + ",\n";
    str = str.substring(0, str.length()-2)+"]";
    return str;
}
private static String str1d(double[] a){
    String str = "[";
    for(double d: a)
        str = str+d+", ";
    str = str.substring(0, str.length()-2)+"]";
    return str;
}
}

结构快速解释：每个节点都有一个激活函数 f；f.eval评估函数并f.deriv评估其导数。Functions.SIG是标准的 sigmoidal 函数，Functions.HSF是 Heaviside 阶跃函数。为了设置函数的输入，你调用addIW一个已经包含前一个输出权重的值。在反向传播中使用addEW. 节点被组织在一个 2d 数组中，权重被单独组织在一个 3d 数组中，如前所述。

我意识到这可能有点要求 - 我当然知道这段代码打破了多少 Java 约定 - 但我感谢任何人可以提供的任何帮助。

编辑：由于这个问题和我的代码是如此巨大的文本墙，如果有一行涉及括号中的许多复杂表达式而您不想弄清楚，请添加评论或询问我的内容，我会尝试回答尽快。

编辑 2：这里的具体问题是该网络不会在 XOR 上收敛。这里有一些输出来说明这一点：

9995: {1.0, 0.0}: 1 1
9996: {0.0, 1.0}: 1 1
9997: {0.0, 0.0}: 0 1
9998: {0.0, 1.0}: 1 0
9999: {0.0, 1.0}: 1 1
每一行的格式都是TEST NUMBER: {INPUTS}: EXPECTED ACTUAL The network calls trainwith each test，所以这个网络反向传播了 10000 次。

如果有人想运行它，这里有两个额外的类：

package util;

public class Functions {
public static final ActivationFunction LIN = new ActivationFunction(){
            public double eval(double x) {
                return x;
            }

            public double deriv(double x) {
                return 1;
            }
};
public static final ActivationFunction SIG = new ActivationFunction(){
            public double eval(double x) {
                return 1/(1+Math.exp(-x));
            }

            public double deriv(double x) {
                double ev = eval(x);
                return ev * (1-ev);
            }
};
public static final ActivationFunction HSF = new ActivationFunction(){
            public double eval(double x) {
                if(x>0) return 1;
                return 0;
            }

            public double deriv(double x) {
                return (1);
            }
};
}

package util;

public interface ActivationFunction {
public double eval(double x);
public double deriv(double x);
}

现在它甚至更长。该死。

4

1 回答 1

1

在您的主要方法中：

double[] in = {Math.round(Math.random()),Math.round(Math.random())};
int out = 0;
if(in[1]==1 ^ in[0] ==1) out = 1;

您创建一个接收目标 0 的随机输入（1 和 0 的组合）。由于Math.random具有特定的内部种子（没有真正的随机性），您无法保证超过 10000 次迭代 XOR 的所有 4 个输入都是由平衡生成的用这种技术量。这反过来意味着有可能在 10000 次迭代{0.0,0.0}中只训练了几百次，而{1.0,0.0} {0.0,1.0}训练了大约 8000 次。如果是这种情况，这将清楚地解释您的结果并限制您的训练。

与其随机生成输入数据，不如从其中随机选择。保留外部（epochs）循环并引入第二个循环，您可以在其中选择一个您在此 epoch 中尚未选择的随机样本（或者简单地按顺序遍历您的数据而没有任何随机性，这对于 XOR 来说不是真正的问题）。没有任何随机性的伪代码：

// use a custom class to realize the data structure (that defines the target values):
TrainingSet = { {(0,0),0}, {(0,1),1}, {(1,0),1}, {(1,1),0} } 
for epochNr < epochs:
    while(TrainingSet.hasNext()):
        input = TrainingSet.getNext();
        network.feedInput(input)

这样你就可以保证每个样本在 10000 次迭代中被看到 2500 次。

于 2015-07-06T10:28:40.360 回答