Category

Development Platform
Home > SourceCode/Document > Windows Develop > View Code
SigmoidUnit.java
Package: Weka-3-2.rar　[view]
Upload User: rhdiban
Upload Date: 2013-08-09
Package Size: 15085k
Code Size: 3k
Category:

Windows Develop

Development Platform:

Java

SigmoidUnit.java：Code Content
  1. /*
  2.  *    This program is free software; you can redistribute it and/or modify
  3.  *    it under the terms of the GNU General Public License as published by
  4.  *    the Free Software Foundation; either version 2 of the License, or
  5.  *    (at your option) any later version.
  6.  *
  7.  *    This program is distributed in the hope that it will be useful,
  8.  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  9.  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10.  *    GNU General Public License for more details.
  11.  *
  12.  *    You should have received a copy of the GNU General Public License
  13.  *    along with this program; if not, write to the Free Software
  14.  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  15.  */
  17. /*
  18.  *    SigmoidUnit.java
  19.  *    Copyright (C) 2001 Malcolm Ware
  20.  */
  23. package weka.classifiers.functions.neural;
  27. /**
  28.  * This can be used by the 
  29.  * neuralnode to perform all it's computations (as a sigmoid unit).
  30.  *
  31.  * @author Malcolm Ware (mfw4@cs.waikato.ac.nz)
  32.  * @version $Revision: 1.3 $
  33.  */
  34. public class SigmoidUnit implements NeuralMethod {
  36.   
  37.   /**
  38.    * This function calculates what the output value should be.
  39.    * @param node The node to calculate the value for.
  40.    * @return The value.
  41.    */
  42.   public double outputValue(NeuralNode node) {
  43.     double[] weights = node.getWeights();
  44.     NeuralConnection[] inputs = node.getInputs();
  45.     double value = weights[0];
  46.     for (int noa = 0; noa < node.getNumInputs(); noa++) {
  47.       
  48.       value += inputs[noa].outputValue(true) 
  49. * weights[noa+1];
  50.     }
  51.      
  52.     //this I got from the Neural Network faq to combat overflow
  53.     //pretty simple solution really :)
  54.     if (value < -45) {
  55.       value = 0;
  56.     }
  57.     else if (value > 45) {
  58.       value = 1;
  59.     }
  60.     else {
  61.       value = 1 / (1 + Math.exp(-value));
  62.     }  
  63.     return value;
  64.   }
  65.   
  66.   /**
  67.    * This function calculates what the error value should be.
  68.    * @param node The node to calculate the error for.
  69.    * @return The error.
  70.    */
  71.   public double errorValue(NeuralNode node) {
  72.     //then calculate the error.
  73.     
  74.     NeuralConnection[] outputs = node.getOutputs();
  75.     int[] oNums = node.getOutputNums();
  76.     double error = 0;
  77.     
  78.     for (int noa = 0; noa < node.getNumOutputs(); noa++) {
  79.       error += outputs[noa].errorValue(true) 
  80. * outputs[noa].weightValue(oNums[noa]);
  81.     }
  82.     double value = node.outputValue(false);
  83.     error *= value * (1 - value);
  84.     
  85.     return error;
  86.   }
  88.   /**
  89.    * This function will calculate what the change in weights should be
  90.    * and also update them.
  91.    * @param node The node to update the weights for.
  92.    * @param learn The learning rate to use.
  93.    * @param momentum The momentum to use.
  94.    */
  95.   public void updateWeights(NeuralNode node, double learn, double momentum) {
  97.     NeuralConnection[] inputs = node.getInputs();
  98.     double[] cWeights = node.getChangeInWeights();
  99.     double[] weights = node.getWeights();
  100.     double learnTimesError = 0;
  101.     try {
  102.       learnTimesError = learn * node.errorValue(false);
  103.     } catch(Exception e) {}
  104.     double c = learnTimesError + momentum * cWeights[0];
  105.     weights[0] += c;
  106.     cWeights[0] = c;
  107.  
  108.     int stopValue = node.getNumInputs() + 1;
  109.     for (int noa = 1; noa < stopValue; noa++) {
  110.       
  111.       c = learnTimesError * inputs[noa-1].outputValue(false);
  112.       c += momentum * cWeights[noa];
  113.       
  114.       weights[noa] += c;
  115.       cWeights[noa] = c; 
  116.     }
  117.   }
  118.     
  119. }