感知器的總結工作不正常。得到大的總和

Question

所以我有一個運行方法，用輸入節點的閾值來加權人工神經網絡中邊緣的權重。

排序是這樣的：

現在我的測試感知應該產生的-3的總和，但我得到的1176值！這裏發生了什麼？

這是我爲run（）方法，構造函數和主要方法編寫的代碼。

構造：

public class Perceptron { 

//We want to create a variable which will represent the number of weighted edges 
//in the 2-dimensional array. 
protected int num_weighted_Edges; 

//Inside this class we want to create a data field which is a 
//2-D array of WeightedEdges. Since the weightedEdges will be in 
//double data type, we will create a double type 2-dimensional 
//array. 
protected WeightedEdge[][] weightedEdges; 

protected int[] weights; 

//We set a double field named eta equal to 0.05. 
protected double eta = 0.05; 

//We initialize a constructor which only takes a parameter int n. 
public Perceptron(int n){ 

    //We want to create a new graph which will have n + 1 vertices 
    //, where we also want vertex 0 to act like the output node 
    //as in a neural network. 
    this.num_weighted_Edges = n; 

    weights = new int[num_weighted_Edges]; 

    //First we need to verify that n is a positive real number 
    if (num_weighted_Edges < 0){ 
     throw new RuntimeException("You cannot have a perceptron of negative value"); 
    } 
    else { 
     //Test code for testing if this code works. 
     System.out.println("A perceptron of " + num_weighted_Edges + " input nodes, and 1 output node was created"); 
    } 

    //Now we create a graph object with "n" number of vertices. 
    weightedEdges = new WeightedEdge[num_weighted_Edges + 1][num_weighted_Edges + 1]; 

    //Create a for loop that will iterate the weightedEdges array. 
    //We want to create the weighted edges from vertex 1 and not vertex 0 
    //since vertex 0 will be the output node, so we set i = 1. 
    for (int i = 1; i < weightedEdges.length; i++){ 
     for (int j = 0; j < weightedEdges[i].length; j++){ 
      //This will create a weighted edge in between [1][0]...[2][0]...[3][0] 
      //The weighted edge will have a random value between -1 and 1 assigned to it. 
      weightedEdges[i][0] = new WeightedEdge(i, j, 1); 
     } 
    } 

} 

這是我的run（）方法：

//This method will take the input nodes, do a quick verification check on it and 
//sum up the weights using the simple threshold function described in class to return 
//either a 1 or -1. 1 meaning fire, and -1 not firing. 
public int run(int[] weights){ 
    //So this method will act like the summation function. It will take the int parameters 
    //you put into the parameter field and multiply it times the input nodes in the 
    //weighted edge 2 d array. 

    //Setup a summation counter. 
    int sum = 0; 

    if (weights.length != num_weighted_Edges){ 
     throw new RuntimeException("Array coming in has to equal the number of input nodes"); 
    } 
    else { 
     //We iterate the weights array and use the sum counter to sum up weights. 
     for (int i = 0; i < weights.length; i++){ 
      //Create a nested for loop which will iterate over the input nodes 
      for (int j = 1; j < weightedEdges.length; j++){ 
       for (int k = 0; k < weightedEdges[j].length; k++){ 
        //This takes the weights and multiplies it times the value in the 
        //input nodes. The sum should equal greater than 0 or less than 0. 
        sum += (int) ((weightedEdges[j][0].getWeight()) * i); 
        //Here the plus equals sign takes the product of (weightedEdges[j][0] * i) and 
        //then adds it to the previous value. 
       } 
      } 
     } 
    } 

    System.out.println(sum); 

    //If the sum is greater than 0, we fire the neuron by returning 1. 
    if (sum > 0){ 
     //System.out.println(1); test code 
     return 1; 
    } 
    //Else we don't fire and return -1. 
    else { 
     //System.out.println(-1); test code 
     return -1; 
    } 

} 

這是我的主要方法：

//Main method which will stimulate the artificial neuron (perceptron, which is the 
//simplest type of neuron in an artificial network). 
public static void main(String[] args){ 

    //Create a test perceptron with a user defined set number of nodes. 
    Perceptron perceptron = new Perceptron(7); 

    //Create a weight object that creates an edge between vertices 1 and 2 
    //with a weight of 1.5 
    WeightedEdge weight = new WeightedEdge(1, 2, 1.5); 

    //These methods work fine. 
    weight.getStart(); 
    weight.getEnd(); 
    weight.setWeight(2.0); 

    //Test to see if the run class works. (Previously was giving a null pointer, but 
    //fixed now) 
    int[] test_weight_Array = {-1, -1, -1, -1, -1, 1, 1}; 

    //Tested and works to return output of 1 or -1. Also catches exceptions. 
    perceptron.run(test_weight_Array); 

    //Testing a 2-d array to see if the train method works. 
    int[][] test_train_Array = {{1}, {-1}, {1}, {1}, {1}, {1}, {1}, {1}}; 

    //Works and catches exceptions. 
    perceptron.train(test_train_Array); 

} 

    } 

Answer 1

我想你應該改變

sum += (int) ((weightedEdges[j][0].getWeight()) * i); 

到

sum += (int) ((weightedEdges[j][k].getWeight()) * i);