Neuronales Netzwerk liefert den gleichen Ausgang für jeden Eingang

Question

Ich habe ein einfaches Künstliches Neuronales Netzwerk in Java als Teil eines Projekts geschrieben. Wenn ich mit dem Training der Daten beginne (unter Verwendung eines Trainingssatzes, den ich gesammelt habe), stabilisiert sich die Fehlerzahl in jeder Epoche schnell (auf ungefähr 30% Genauigkeit) und stoppt dann. Beim Testen des KNN sind alle Ausgänge für jeden gegebenen Eingang GENAU identisch.

Ich versuche, eine Zahl zwischen 0 und 1 Ausgang (0 eine Aktie als faller zu klassifizieren und 1 zu einer Riser zu klassifizieren - 0,4-0,6 sollte Stabilität zeigen)

Beim Hinzufügen der gleichen Trainingsdaten in Rapidminer Studios ein richtiger ANN mit viel größer (70 +%) Genauigkeit wird erstellt, daher weiß ich, dass der Datensatz in Ordnung ist. Es muss ein Problem in der ANN-Logik geben.

Unten ist der Code zum Ausführen und Anpassen der Gewichte. Irgendwelche Hilfe geschätzt!

public double[] Run(double[] inputs) { 
    //INPUTS 
    for (int i = 0; i < inputNeurons.length; i++) { 
     inputNeurons[i] = inputs[i]; 
    } 

    for (int i = 0; i < hiddenNeurons.length; i++) { 
     hiddenNeurons[i] = 0; 
    } //RESET THE HIDDEN NEURONS 

    for (int e = 0; e < inputNeurons.length; e++) { 
     for (int i = 0; i < hiddenNeurons.length; i++) { 
      //Looping through each input neuron connected to each hidden neuron 

      hiddenNeurons[i] += inputNeurons[e] * inputWeights[(e * hiddenNeurons.length) + i]; 
      //Summation (with the adding of neurons) - Done by taking the sum of each (input * connection weight) 
      //The more weighting a neuron has the more "important" it is in decision making 
     } 
    } 

    for (int j = 0; j < hiddenNeurons.length; j++) { 
     hiddenNeurons[j] = 1/(1 + Math.exp(-hiddenNeurons[j])); 
     //sigmoid function transforms the output into a real number between 0 and 1 
    } 

    //HIDDEN 
    for (int i = 0; i < outputNeurons.length; i++) { 
     outputNeurons[i] = 0; 
    } //RESET THE OUTPUT NEURONS 

    for (int e = 0; e < hiddenNeurons.length; e++) { 
     for (int i = 0; i < outputNeurons.length; i++) { 
      //Looping through each hidden neuron connected to each output neuron 

      outputNeurons[i] += hiddenNeurons[e] * hiddenWeights[(e * outputNeurons.length) + i]; 
      //Summation (with the adding of neurons) as above 
     } 
    } 

    for (int j = 0; j < outputNeurons.length; j++) { 
     outputNeurons[j] = 1/(1 + Math.exp(-outputNeurons[j])); //sigmoid function as above 
    } 

    double[] outputs = new double[outputNeurons.length]; 
    for (int j = 0; j < outputNeurons.length; j++) { 
     //Places all output neuron values into an array 
     outputs[j] = outputNeurons[j]; 
    } 
    return outputs; 
} 

public double[] CalculateErrors(double[] targetValues) { 
    //Compares the given values to the actual values 
    for (int k = 0; k < outputErrors.length; k++) { 
     outputErrors[k] = targetValues[k] - outputNeurons[k]; 
    } 
    return outputErrors; 
} 

    public void tuneWeights() //Back Propagation 
{ 
    // Start from the end - From output to hidden 
    for (int p = 0; p < this.hiddenNeurons.length; p++)  //For all Hidden Neurons 
    { 
     for (int q = 0; q < this.outputNeurons.length; q++) //For all Output Neurons 
     { 
      double delta = this.outputNeurons[q] * (1 - this.outputNeurons[q]) * this.outputErrors[q]; 
      //DELTA is the error for the output neuron q 
      this.hiddenWeights[(p * outputNeurons.length) + q] += this.learningRate * delta * this.hiddenNeurons[p]; 
      /*Adjust the particular weight relative to the error 
      *If the error is large, the weighting will be decreased 
      *If the error is small, the weighting will be increased 
      */ 
     } 
    } 

    // From hidden to inps -- Same as above 
    for (int i = 0; i < this.inputNeurons.length; i++)  //For all Input Neurons 
    { 
     for (int j = 0; j < this.hiddenNeurons.length; j++) //For all Hidden Neurons 
     { 
      double delta = this.hiddenNeurons[j] * (1 - this.hiddenNeurons[j]); 
      double x = 0;  //We do not have output errors here so we must use extra data from Output Neurons 
      for (int k = 0; k < this.outputNeurons.length; k++) { 
       double outputDelta = this.outputNeurons[k] * (1 - this.outputNeurons[k]) * this.outputErrors[k]; 
       //We calculate the output delta again 
       x = x + outputDelta * this.hiddenWeights[(j * outputNeurons.length) + k]; 
       //We then calculate the error based on the hidden weights (x is used to add the error values of all weights) 
       delta = delta * x; 
      } 
      this.inputWeights[(i * hiddenNeurons.length) + j] += this.learningRate * delta * this.inputNeurons[i]; 
      //Adjust weight like above 
     } 
    } 
} 

Answer 1

Nach langer coversation denke ich, dass Sie eine Antwort auf Ihre Frage in den folgenden Punkten finden:

1. Bias wirklich wichtig ist. Eigentlich - eine der beliebtesten SO-Fragen über neuronales Netzwerk ist über Bias :): Role of Bias in Neural Networks
2. Sie sollten Ihren Lernprozess babysitten. Es ist gut, Ihren Test bezüglich Genauigkeit und Validierungsset zu verfolgen und während des Trainings eine angemessene Lernrate zu verwenden. Ich rate Ihnen, einen einfacheren Datensatz zu verwenden, wenn Sie wissen, dass es einfach ist, eine echte Lösung zu finden (zum Beispiel - ein Dreieck oder ein Quadrat - verwenden Sie dann 4 - 5 versteckte Einheiten). Ich rate Ihnen auch die folgenden playgroud zu verwenden:

http://playground.tensorflow.org/#activation=tanh&batchSize=10&dataset=circle&regDataset=reg-plane&learningRate=0.03&regularizationRate=0&noise=0&networkShape=4,2&seed=0.36368&showTestData=false&discretize=false&percTrainData=50&x=true&y=true&xTimesY=false&xSquared=false&ySquared=false&cosX=false&sinX=false&cosY=false&sinY=false&collectStats=false&problem=classification