• Home
• com.github.fracpete
• wekaclassalgos
• 2023.2.8
• source code
• BackPropagation.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

weka.classifiers.neural.multilayerperceptron.BackPropagation Maven / Gradle / Ivy

/*
 *   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 3 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, see .
 */

package weka.classifiers.neural.multilayerperceptron;

import weka.classifiers.neural.common.NeuralModel;
import weka.classifiers.neural.common.SimpleNeuron;
import weka.classifiers.neural.common.WekaAlgorithmAncestor;
import weka.classifiers.neural.common.learning.LearningKernelFactory;
import weka.classifiers.neural.common.learning.LearningRateKernel;
import weka.classifiers.neural.common.training.TrainerFactory;
import weka.classifiers.neural.common.transfer.TransferFunction;
import weka.classifiers.neural.common.transfer.TransferFunctionFactory;
import weka.classifiers.neural.multilayerperceptron.algorithm.BackPropagationAlgorithm;
import weka.core.Instances;
import weka.core.Option;
import weka.core.SelectedTag;
import weka.core.Utils;

import java.util.ArrayList;
import java.util.Collection;

/**
 * 
Title: Weka Neural Implementation
 * 
Description: ...
 * 
Copyright: Copyright (c) 2003
 * 
Company: N/A
 *
 * @author Jason Brownlee
 * @version 1.0
 */

public class BackPropagation extends WekaAlgorithmAncestor {

  public final static int PARAM_TRANSFER_FUNCTION = 0;

  public final static int PARAM_TRAINING_MODE = 1;

  public final static int PARAM_MOMENTUM = 2;

  public final static int PARAM_WEIGHT_DECAY = 3;

  public final static int PARAM_HIDDEN_1 = 4;

  public final static int PARAM_HIDDEN_2 = 5;

  public final static int PARAM_HIDDEN_3 = 6;

  public final static int PARAM_LEARNING_RATE_FUNCTION = 7;

  // param flags
  public final static String[] EXTRA_PARAMETERS =
    {
      "F", // transfer function
      "N", // training mode
      "A", // momentum
      "D",  // weight decay
      "X",  // hidden layer 1 num nodes
      "Y",  // hidden layer 2 num nodes
      "Z",  // hidden layer 3 num nodes
      "M" // learning rate function
    };


  public final static String[] EXTRA_PARAMETER_NOTES =
    {
      "", // transfer function
      "", // training mode
      "", // momentum
      "",  // weight decay
      "",  // hidden layer 1 num nodes
      "",  // hidden layer 2 num nodes
      "",  // hidden layer 3 num nodes
      "" // learning rate function
    };

  // descriptions for all parameters
  public final static String[] EXTRA_PARAM_DESCRIPTIONS =
    {
      "Neuron transfer function " + TransferFunctionFactory.DESCRIPTION,
      "Model training algorithm " + TrainerFactory.DESCRIPTION,
      "Momentum Factor (recommend between 0.0 and 0.9, 0.0==not used)",
      "Weight Decay Factor (recommend between 0.0 and 1.0, 0.0==not used)",
      "The number of nodes in the first hidden layer (0 for none)",
      "The number of nodes in the second hidden layer (0 for none)",
      "The number of nodes in the third hidden layer (0 for none)",
      "Learning rate function to use while training, static is typically better " + LearningKernelFactory.DESCRIPTION
    };


  // momentum
  protected double momentum = 0.0;

  // weight decay
  protected double weightDecay = 0.0;

  // topology
  protected int hiddenLayer1 = 0;

  protected int hiddenLayer2 = 0;

  protected int hiddenLayer3 = 0;


  public BackPropagation() {
    // set good initial values
    transferFunction = TransferFunctionFactory.TRANSFER_SIGMOID;
    trainingMode = TrainerFactory.TRAINER_BATCH;
    trainingIterations = 500;
    biasInput = SimpleNeuron.DEFAULT_BIAS_VALUE;
    learningRate = 0.1;
    learningRateFunction = LearningKernelFactory.LEARNING_FUNCTION_STATIC;
    randomNumberSeed = 0;

    momentum = 0.2;
    weightDecay = 0.0;
    hiddenLayer1 = 0;
    hiddenLayer2 = 0;
    hiddenLayer3 = 0;
  }


  protected NeuralModel prepareAlgorithm(Instances instances) throws java.lang.Exception {
    int[] hiddenLayersTopology = null;

    // prepare the transfer function
    TransferFunction function = TransferFunctionFactory.factory(transferFunction);
    // prepare the learning rate function
    LearningRateKernel lrateFunction = LearningKernelFactory.factory(learningRateFunction, learningRate, trainingIterations);

    // prepare hidden layers topology
    if (hiddenLayer1 <= 0) {
      hiddenLayersTopology = null;
    }
    else if (hiddenLayer2 <= 0) {
      hiddenLayersTopology = new int[]{hiddenLayer1};
    }
    else if (hiddenLayer3 <= 0) {
      hiddenLayersTopology = new int[]{hiddenLayer1, hiddenLayer2};
    }
    else {
      // all three hidden layers were specified
      hiddenLayersTopology = new int[]{hiddenLayer1, hiddenLayer2, hiddenLayer3};
    }

    // construct the algorithm
    BackPropagationAlgorithm algorithm = new BackPropagationAlgorithm(function, rand, lrateFunction, momentum, weightDecay, biasInput, hiddenLayersTopology, instances);


    return algorithm;

  }

  protected Collection getAlgorithmOptions() {
    ArrayList list = new ArrayList();

    list.add("-" + EXTRA_PARAMETERS[PARAM_TRANSFER_FUNCTION]);
    list.add(Integer.toString(transferFunction));

    list.add("-" + EXTRA_PARAMETERS[PARAM_TRAINING_MODE]);
    list.add(Integer.toString(trainingMode));

    list.add("-" + EXTRA_PARAMETERS[PARAM_MOMENTUM]);
    list.add(Double.toString(momentum));

    list.add("-" + EXTRA_PARAMETERS[PARAM_WEIGHT_DECAY]);
    list.add(Double.toString(weightDecay));

    list.add("-" + EXTRA_PARAMETERS[PARAM_HIDDEN_1]);
    list.add(Integer.toString(hiddenLayer1));

    list.add("-" + EXTRA_PARAMETERS[PARAM_HIDDEN_2]);
    list.add(Integer.toString(hiddenLayer2));

    list.add("-" + EXTRA_PARAMETERS[PARAM_HIDDEN_3]);
    list.add(Integer.toString(hiddenLayer3));

    list.add("-" + EXTRA_PARAMETERS[PARAM_LEARNING_RATE_FUNCTION]);
    list.add(Integer.toString(learningRateFunction));

    return list;
  }

  protected Collection getListOptions() {
    ArrayList list = new ArrayList();

    for (int i = 0; i < EXTRA_PARAMETERS.length; i++) {
      String param = "-" + EXTRA_PARAMETERS[i] + " " + EXTRA_PARAMETER_NOTES[i];
      list.add(new Option("\t" + EXTRA_PARAM_DESCRIPTIONS[i], EXTRA_PARAMETERS[i], 1, param));
    }

    return list;
  }

  public String globalInfo() {
    StringBuilder buffer = new StringBuilder();

    buffer.append("Back Propagation Learning Rule, variable number of hidden layers (0-3)");

    return buffer.toString();
  }

  protected void validateArguments() throws java.lang.Exception {
    if (hiddenLayer1 < 0) {
      throw new Exception("There must be >=0 nodes in the first layer: " + hiddenLayer1);
    }
    else if (hiddenLayer2 < 0) {
      throw new Exception("There must be >=0 nodes in the second layer: " + hiddenLayer2);
    }
    else if (hiddenLayer3 < 0) {
      throw new Exception("There must be >=0 nodes in the third layer: " + hiddenLayer3);
    }
    // check for valid topology
    else if (hiddenLayer2 > 0 && hiddenLayer1 == 0) {
      throw new Exception("A first layer must be specified to allow a second layer");
    }
    else if (hiddenLayer3 > 0 && hiddenLayer2 == 0) {
      throw new Exception("A second layer must be specified to allow a third layer");
    }
  }

  protected void setArguments(String[] options)
    throws Exception {
    for (int i = 0; i < EXTRA_PARAMETERS.length; i++) {
      String data = Utils.getOption(EXTRA_PARAMETERS[i].charAt(0), options);

      if (data == null || data.length() == 0) {
	continue;
      }

      switch (i) {
	case PARAM_TRANSFER_FUNCTION: {
	  transferFunction = Integer.parseInt(data);
	  break;
	}
	case PARAM_TRAINING_MODE: {
	  trainingMode = Integer.parseInt(data);
	  break;
	}
	case PARAM_MOMENTUM: {
	  momentum = Double.parseDouble(data);
	  break;
	}
	case PARAM_WEIGHT_DECAY: {
	  weightDecay = Double.parseDouble(data);
	  break;
	}
	case PARAM_HIDDEN_1: {
	  hiddenLayer1 = Integer.parseInt(data);
	  break;
	}
	case PARAM_HIDDEN_2: {
	  hiddenLayer2 = Integer.parseInt(data);
	  break;
	}
	case PARAM_HIDDEN_3: {
	  hiddenLayer3 = Integer.parseInt(data);
	  break;
	}
	case PARAM_LEARNING_RATE_FUNCTION: {
	  learningRateFunction = Integer.parseInt(data);
	  break;
	}
	default: {
	  throw new Exception("Invalid option offset: " + i);
	}
      }
    }
  }


  public String transferFunctionTipText() {
    return EXTRA_PARAM_DESCRIPTIONS[PARAM_TRANSFER_FUNCTION];
  }

  public String trainingModeTipText() {
    return EXTRA_PARAM_DESCRIPTIONS[PARAM_TRAINING_MODE];
  }

  public String momentumTipText() {
    return EXTRA_PARAM_DESCRIPTIONS[PARAM_MOMENTUM];
  }

  public String weightDecayTipText() {
    return EXTRA_PARAM_DESCRIPTIONS[PARAM_WEIGHT_DECAY];
  }

  public String hiddenLayer1TipText() {
    return EXTRA_PARAM_DESCRIPTIONS[PARAM_HIDDEN_1];
  }

  public String hiddenLayer2TipText() {
    return EXTRA_PARAM_DESCRIPTIONS[PARAM_HIDDEN_2];
  }

  public String hiddenLayer3TipText() {
    return EXTRA_PARAM_DESCRIPTIONS[PARAM_HIDDEN_3];
  }

  public String learningRateFunctionTipText() {
    return EXTRA_PARAM_DESCRIPTIONS[PARAM_LEARNING_RATE_FUNCTION];
  }


  public void setLearningRateFunction(SelectedTag l) {
    if (l.getTags() == LearningKernelFactory.TAGS_LEARNING_FUNCTION) {
      learningRateFunction = l.getSelectedTag().getID();
    }
  }

  public SelectedTag getLearningRateFunction() {
    return new SelectedTag(learningRateFunction, LearningKernelFactory.TAGS_LEARNING_FUNCTION);
  }


  public void setTransferFunction(SelectedTag l) {
    if (l.getTags() == TransferFunctionFactory.TAGS_TRANSFER_FUNCTION) {
      transferFunction = l.getSelectedTag().getID();
    }
  }

  public SelectedTag getTransferFunction() {
    return new SelectedTag(transferFunction, TransferFunctionFactory.TAGS_TRANSFER_FUNCTION);
  }


  public void setTrainingMode(SelectedTag l) {
    if (l.getTags() == TrainerFactory.TAGS_TRAINING_MODE) {
      trainingMode = l.getSelectedTag().getID();
    }
  }

  public SelectedTag getTrainingMode() {
    return new SelectedTag(trainingMode, TrainerFactory.TAGS_TRAINING_MODE);
  }

  public double getMomentum() {
    return momentum;
  }

  public void setMomentum(double m) {
    momentum = m;
  }


  public double getWeightDecay() {
    return weightDecay;
  }

  public void setWeightDecay(double w) {
    weightDecay = w;
  }

  public int getHiddenLayer1() {
    return hiddenLayer1;
  }

  public void setHiddenLayer1(int h) {
    hiddenLayer1 = h;
  }

  public int getHiddenLayer2() {
    return hiddenLayer2;
  }

  public void setHiddenLayer2(int h) {
    hiddenLayer2 = h;
  }

  public int getHiddenLayer3() {
    return hiddenLayer3;
  }

  public void setHiddenLayer3(int h) {
    hiddenLayer3 = h;
  }

  /**
   * Entry point into the algorithm for direct usage
   *
   * @param args
   */
  public static void main(String[] args) {
    runClassifier(new BackPropagation(), args);
  }
}