/* *    This program is free software; you can redistribute it and/or modify *    it under the terms of the GNU General Public License as published by *    the Free Software Foundation; either version 2 of the License, or *    (at your option) any later version. * *    This program is distributed in the hope that it will be useful, *    but WITHOUT ANY WARRANTY; without even the implied warranty of *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the *    GNU General Public License for more details. * *    You should have received a copy of the GNU General Public License *    along with this program; if not, write to the Free Software *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *//* *    NeuralNode.java *    Copyright (C) 2000 Malcolm Ware */package weka.classifiers.functions.neural;import java.util.Random;/** * This class is used to represent a node in the neuralnet. * @author Malcolm Ware (mfw4@cs.waikato.ac.nz) * @version $Revision: 1.5 $ */public class NeuralNode extends NeuralConnection {      /** The weights for each of the input connections, and the threshold. */  private double[] m_weights;    /** The change in the weights. */  private double[] m_changeInWeights;    private Random m_random;  /** Performs the operations for this node. Currently this   * defines that the node is either a sigmoid or a linear unit. */  private NeuralMethod m_methods;  /**    * @param id The string name for this node (used to id this node).   * @param r A random number generator used to generate initial weights.   * @param m The methods this node should use to update.   */  public NeuralNode(String id, Random r, NeuralMethod m) {    super(id);    m_weights = new double[1];    m_changeInWeights = new double[1];        m_random = r;        m_weights[0] = m_random.nextDouble() * .1 - .05;    m_changeInWeights[0] = 0;    m_methods = m;  }    /**   * Set how this node should operate (note that the neural method has no   * internal state, so the same object can be used by any number of nodes.   * @param m The new method.   */  public void setMethod(NeuralMethod m) {    m_methods = m;  }   public NeuralMethod getMethod() {    return m_methods;  }  /**   * Call this to get the output value of this unit.    * @param calculate True if the value should be calculated if it hasn't been   * already.   * @return The output value, or NaN, if the value has not been calculated.   */  public double outputValue(boolean calculate) {        if (Double.isNaN(m_unitValue) && calculate) {      //then calculate the output value;      m_unitValue = m_methods.outputValue(this);    }        return m_unitValue;  }    /**   * Call this to get the error value of this unit.   * @param calculate True if the value should be calculated if it hasn't been   * already.   * @return The error value, or NaN, if the value has not been calculated.   */  public double errorValue(boolean calculate) {    if (!Double.isNaN(m_unitValue) && Double.isNaN(m_unitError) && calculate) {      //then calculate the error.      m_unitError = m_methods.errorValue(this);    }    return m_unitError;  }  /**   * Call this to reset the value and error for this unit, ready for the next   * run. This will also call the reset function of all units that are    * connected as inputs to this one.   * This is also the time that the update for the listeners will be performed.   */  public void reset() {        if (!Double.isNaN(m_unitValue) || !Double.isNaN(m_unitError)) {      m_unitValue = Double.NaN;      m_unitError = Double.NaN;      m_weightsUpdated = false;      for (int noa = 0; noa < m_numInputs; noa++) {	m_inputList[noa].reset();      }    }  }  /**   * Call this to get the weight value on a particular connection.   * @param n The connection number to get the weight for, -1 if The threshold   * weight should be returned.   * @return The value for the specified connection or if -1 then it should    * return the threshold value. If no value exists for the specified    * connection, NaN will be returned.   */  public double weightValue(int n) {    if (n >= m_numInputs || n < -1) {      return Double.NaN;    }    return m_weights[n + 1];  }  /**   * call this function to get the weights array.   * This will also allow the weights to be updated.   * @return The weights array.   */  public double[] getWeights() {    return m_weights;  }  /**   * call this function to get the chnage in weights array.   * This will also allow the change in weights to be updated.   * @return The change in weights array.   */  public double[] getChangeInWeights() {    return m_changeInWeights;  }  /**   * Call this function to update the weight values at this unit.   * After the weights have been updated at this unit, All the   * input connections will then be called from this to have their   * weights updated.   * @param l The learning rate to use.   * @param m The momentum to use.   */  public void updateWeights(double l, double m) {        if (!m_weightsUpdated && !Double.isNaN(m_unitError)) {      m_methods.updateWeights(this, l, m);           //note that the super call to update the inputs is done here and      //not in the m_method updateWeights, because it is not deemed to be      //required to update the weights at this node (while the error and output      //value ao need to be recursively calculated)      super.updateWeights(l, m); //to call all of the inputs.    }      }  /**   * This will connect the specified unit to be an input to this unit.   * @param i The unit.   * @param n It's connection number for this connection.   * @return True if the connection was made, false otherwise.   */  protected boolean connectInput(NeuralConnection i, int n) {        //the function that this overrides can do most of the work.    if (!super.connectInput(i, n)) {      return false;    }        //note that the weights are shifted 1 forward in the array so    //it leaves the numinputs aligned on the space the weight needs to go.    m_weights[m_numInputs] = m_random.nextDouble() * .1 - .05;    m_changeInWeights[m_numInputs] = 0;        return true;  }  /**   * This will allocate more space for input connection information   * if the arrays for this have been filled up.   */  protected void allocateInputs() {        NeuralConnection[] temp1 = new NeuralConnection[m_inputList.length + 15];    int[] temp2 = new int[m_inputNums.length + 15];    double[] temp4 = new double[m_weights.length + 15];    double[] temp5 = new double[m_changeInWeights.length + 15];    temp4[0] = m_weights[0];    temp5[0] = m_changeInWeights[0];    for (int noa = 0; noa < m_numInputs; noa++) {      temp1[noa] = m_inputList[noa];      temp2[noa] = m_inputNums[noa];      temp4[noa+1] = m_weights[noa+1];      temp5[noa+1] = m_changeInWeights[noa+1];    }        m_inputList = temp1;    m_inputNums = temp2;    m_weights = temp4;    m_changeInWeights = temp5;  }      /**   * This will disconnect the input with the specific connection number   * From this node (only on this end however).   * @param i The unit to disconnect.   * @param n The connection number at the other end, -1 if all the connections   * to this unit should be severed (not the same as removeAllInputs).   * @return True if the connection was removed, false if the connection was    * not found.   */  protected boolean disconnectInput(NeuralConnection i, int n) {        int loc = -1;    boolean removed = false;    do {      loc = -1;      for (int noa = 0; noa < m_numInputs; noa++) {	if (i == m_inputList[noa] && (n == -1 || n == m_inputNums[noa])) {	  loc = noa;	  break;	}      }            if (loc >= 0) {	for (int noa = loc+1; noa < m_numInputs; noa++) {	  m_inputList[noa-1] = m_inputList[noa];	  m_inputNums[noa-1] = m_inputNums[noa];	  	  m_weights[noa] = m_weights[noa+1];	  m_changeInWeights[noa] = m_changeInWeights[noa+1];	  	  m_inputList[noa-1].changeOutputNum(m_inputNums[noa-1], noa-1);	}	m_numInputs--;	removed = true;      }          } while (n == -1 && loc != -1);    return removed;  }    /**   * This function will remove all the inputs to this unit.   * In doing so it will also terminate the connections at the other end.   */  public void removeAllInputs() {    super.removeAllInputs();        double temp1 = m_weights[0];    double temp2 = m_changeInWeights[0];    m_weights = new double[1];    m_changeInWeights = new double[1];    m_weights[0] = temp1;    m_changeInWeights[0] = temp2;      }    }