基于Java的神经网络---如何实现反向传播

Question

我正在构建一个测试神经网络，但它肯定不起作用。我的主要问题是反向传播。根据我的研究，我知道使用 sigmoid 函数很容易。因此，我通过 (1-Output)(Output)(target-Output) 更新每个权重，但问题是如果我的输出为 1 但我的目标不是？如果在某个时刻它是 1，那么权重更新将始终为 0...现在我只是想把来自 2 个输入神经元的输入相加，所以最佳权重应该是 1 作为输出神经元只需添加其输入即可。我确信我在很多地方都搞砸了，但这是我的代码：

    public class Main {

        public static void main(String[] args) {
            Double[] inputs = {1.0, 2.0};
            ArrayList<Double> answers = new ArrayList<Double>();
            answers.add(3.0);

            net myNeuralNet = new net(2, 1, answers);

            for(int i=0; i<200; i++){

                myNeuralNet.setInputs(inputs);
                myNeuralNet.start();
                myNeuralNet.backpropagation();
                myNeuralNet.printOutput();
                System.out.println("*****");
                for(int j=0; j<myNeuralNet.getOutputs().size(); j++){
                    myNeuralNet.getOutputs().get(j).resetInput();
                    myNeuralNet.getOutputs().get(j).resetOutput();
                    myNeuralNet.getOutputs().get(j).resetNumCalled();
                }
            }
        }

    }


    package myneuralnet;
    import java.util.ArrayList;

    public class net {

    private ArrayList<neuron> inputLayer;
    private ArrayList<neuron> outputLayer;
    private ArrayList<Double> answers;

    public net(Integer numInput, Integer numOut, ArrayList<Double> answers){
        inputLayer = new ArrayList<neuron>();
        outputLayer = new ArrayList<neuron>();
        this.answers = answers;

        for(int i=0; i<numOut; i++){
            outputLayer.add(new neuron(true));
        }

        for(int i=0; i<numInput; i++){
            ArrayList<Double> randomWeights = createRandomWeights(numInput);
            inputLayer.add(new neuron(outputLayer, randomWeights, -100.00, true));
        }

        for(int i=0; i<numOut; i++){
            outputLayer.get(i).setBackConn(inputLayer);
        }
    }

    public ArrayList<neuron> getOutputs(){
        return outputLayer;
    }

    public void backpropagation(){
        for(int i=0; i<answers.size(); i++){
            neuron iOut = outputLayer.get(i);
            ArrayList<neuron> iOutBack = iOut.getBackConn();
            Double iSigDeriv = (1-iOut.getOutput())*iOut.getOutput();
            Double iError = (answers.get(i) - iOut.getOutput());

            System.out.println("Answer: "+answers.get(i) + " iOut: "+iOut.getOutput()+" Error: "+iError+" Sigmoid: "+iSigDeriv);

            for(int j=0; j<iOutBack.size(); j++){
                neuron jNeuron = iOutBack.get(j);
                Double ijWeight = jNeuron.getWeight(i);

                System.out.println("ijWeight: "+ijWeight);
                System.out.println("jNeuronOut: "+jNeuron.getOutput());

                jNeuron.setWeight(i, ijWeight+(iSigDeriv*iError*jNeuron.getOutput()));
            }
        }

        for(int i=0; i<inputLayer.size(); i++){
            inputLayer.get(i).resetInput();
            inputLayer.get(i).resetOutput();
        }
    }

    public ArrayList<Double> createRandomWeights(Integer size){
        ArrayList<Double> iWeight = new ArrayList<Double>();

        for(int i=0; i<size; i++){
            Double randNum = (2*Math.random())-1;
            iWeight.add(randNum);
        }

        return iWeight;
    }

    public void setInputs(Double[] is){
        for(int i=0; i<is.length; i++){
            inputLayer.get(i).setInput(is[i]);
        }
        for(int i=0; i<outputLayer.size(); i++){
            outputLayer.get(i).resetInput();
        }
    }

    public void start(){
        for(int i=0; i<inputLayer.size(); i++){
            inputLayer.get(i).fire();
        }
    }

    public void printOutput(){
        for(int i=0; i<outputLayer.size(); i++){
            System.out.println(outputLayer.get(i).getOutput().toString());
        }
    }

}

package myneuralnet;
import java.util.ArrayList;

public class neuron {

    private ArrayList<neuron> connections;
    private ArrayList<neuron> backconns;
    private ArrayList<Double> weights;
    private Double threshold;
    private Double input;
    private Boolean isOutput = false;
    private Boolean isInput = false;
    private Double totalSignal;
    private Integer numCalled;
    private Double myOutput;

    public neuron(ArrayList<neuron> conns, ArrayList<Double> weights, Double threshold){
        this.connections = conns;
        this.weights = weights;
        this.threshold = threshold;
        this.totalSignal = 0.00;
        this.numCalled = 0;
        this.backconns = new ArrayList<neuron>();
        this.input = 0.00;
    }

    public neuron(ArrayList<neuron> conns, ArrayList<Double> weights, Double threshold, Boolean isin){
        this.connections = conns;
        this.weights = weights;
        this.threshold = threshold;
        this.totalSignal = 0.00;
        this.numCalled = 0;
        this.backconns = new ArrayList<neuron>();
        this.input = 0.00;
        this.isInput = isin;
    }

    public neuron(Boolean tf){
        this.connections = new ArrayList<neuron>();
        this.weights = new ArrayList<Double>();
        this.threshold = 0.00;
        this.totalSignal = 0.00;
        this.numCalled = 0;
        this.isOutput = tf;
        this.backconns = new ArrayList<neuron>();
        this.input = 0.00;
    }

    public void setInput(Double input){
        this.input = input;
    }

    public void setOut(Boolean tf){
        this.isOutput = tf;
    }

    public void resetNumCalled(){
        numCalled = 0;
    }

    public void setBackConn(ArrayList<neuron> backs){
        this.backconns = backs;
    }

    public Double getOutput(){
        return myOutput;
    }

    public Double getInput(){
        return totalSignal;
    }

    public Double getRealInput(){
        return input;
    }

    public ArrayList<Double> getWeights(){
        return weights;
    }

    public ArrayList<neuron> getBackConn(){
        return backconns;
    }

    public Double getWeight(Integer i){
        return weights.get(i);
    }

    public void setWeight(Integer i, Double d){
        weights.set(i, d);
    }

    public void setOutput(Double d){
        myOutput = d;
    }

    public void activation(Double myInput){
        numCalled++;
        totalSignal += myInput;

        if(numCalled==backconns.size() && isOutput){
            System.out.println("Total Sig: "+totalSignal);
            setInput(totalSignal);
            setOutput(totalSignal);
        }
    }

    public void activation(){
        Double activationValue = 1 / (1 + Math.exp(input));
        setInput(activationValue);
        fire();
    }

    public void fire(){
        for(int i=0; i<connections.size(); i++){
            Double iWeight = weights.get(i);
            neuron iConn = connections.get(i);
            myOutput = (1/(1+(Math.exp(-input))))*iWeight;
            iConn.activation(myOutput);
        }
    }

    public void resetInput(){
        input = 0.00;
        totalSignal = 0.00;
    }

    public void resetOutput(){
        myOutput = 0.00;
    }
}

好的，这是很多代码，所以请允许我解释一下。现在网络很简单，只有一个输入层和一个输出层——我想稍后添加一个隐藏层，但现在我正在采取一些小步骤。每层都是神经元的数组列表。输入神经元加载有输入，在此示例中为 1 和 2。这些神经元触发，计算输入的 sigmoid 并将其输出到输出神经元，输出神经元将它们相加并存储值。然后网络通过获取（答案输出）（输出）（1-输出）（特定输入神经元的输出）进行反向传播，并相应地更新权重。很多时候，它循环下去，我得到无穷大，这似乎与负权重或 sigmoid 相关。当这种情况没有发生时，它会收敛到 1，并且由于（1-1 的输出）为 0，我的权重停止更新。

numCalled 和totalSignal 值只是让算法在继续之前等待所有神经元输入。我知道我这样做的方式很奇怪，但是神经元类有一个称为连接的神经元数组列表，用于保存它正向连接的神经元。另一个名为 backconns 的数组列表保存向后连接。我也应该更新正确的权重，因为我得到了神经元 i 和 j 之间的所有反向连接，但对于所有神经元 j（i 上面的层），我只拉动权重 i。对于造成的混乱，我深表歉意——我已经连续几个小时尝试了很多事情，但仍然无法弄清楚。非常感谢任何帮助！

Answer 1

克里斯·毕肖普 (Chris Bishop) 和西蒙·海金 (Simon Haykin) 的著作是一些关于神经网络的最佳教科书。尝试阅读有关反向传播的章节，并理解为什么权重更新规则中的术语是这样的。我要求您这样做的原因是反向传播比乍一看更微妙。如果您对输出层使用线性激活函数（想想为什么要这样做。提示：后处理），或者如果您添加隐藏层，情况会发生一些变化。当我真正读完这本书后，我就更清楚了。

Answer 2

您可能想将您的代码与这个单层感知器进行比较。

我认为你的反向传播算法有一个错误。另外，尝试用方波代替 sigmoid。

http://web.archive.org /web/20101228185321/http://en.literateprograms.org/Perceptron_%28Java%29

Answer 3

如果我的输出为 1 但我的目标不是？

sigmoid 函数 1/(1 + Math.exp(-x)) 永远不会等于 1。当 x 接近无穷大时，lim 等于 0，但这是一个水平渐近线，因此该函数实际上永远不会接触 1。因此，如果这个表达式用于计算所有的输出值，那么你的输出永远不会是 1。所以 (1 - 输出) 不应该等于 0。

我认为你的问题是在计算输出期间。对于神经网络，每个神经元的输出通常是 sigmoid（输入和权重的点积）。换句话说，值=输入1*权重1+输入2*权重2+...（对于神经元的每个权重）+biasWeight。那么该神经元的输出 = 1 / (1 + Math.exp(-value)。如果以这种方式计算，输出将永远不会等于 1。