/*
* Encog(tm) Core v3.4 - Java Version
* http://www.heatonresearch.com/encog/
* https://github.com/encog/encog-java-core
* Copyright 2008-2016 Heaton Research, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* For more information on Heaton Research copyrights, licenses
* and trademarks visit:
* http://www.heatonresearch.com/copyright
*/
package org.encog.util.benchmark;
import org.encog.ml.data.MLDataSet;
import org.encog.ml.data.basic.BasicMLDataSet;
/**
* This benchmark implements a Fahlman Encoder. Though probably not invented by Scott
* Fahlman, such encoders were used in many of his papers, particularly:
*
* "An Empirical Study of Learning Speed in Backpropagation Networks"
* (Fahlman,1988)
*
* It provides a very simple way of evaluating classification neural networks.
* Basically, the input and output neurons are the same in count. However,
* there is a smaller number of hidden neurons. This forces the neural
* network to learn to encode the patterns from the input neurons to a
* smaller vector size, only to be expanded again to the outputs.
*
* The training data is exactly the size of the input/output neuron count.
* Each training element will have a single column set to 1 and all other
* columns set to zero. You can also perform in "complement mode", where
* the opposite is true. In "complement mode" all columns are set to 1,
* except for one column that is 0. The data produced in "complement mode"
* is more difficult to train.
*
* Fahlman used this simple training data to benchmark neural networks when
* he introduced the Quickprop algorithm in the above paper.
*
*/
public class EncoderTrainingFactory {
/**
* Generate an encoder training set over the range [0.0,1.0]. This is the range used by
* Fahlman.
* @param inputCount The number of inputs and outputs.
* @param compl True if the complement mode should be use.
* @return The training set.
*/
public static MLDataSet generateTraining(int inputCount, boolean compl) {
return generateTraining(inputCount,compl,0,1.0);
}
/**
* Generate an encoder over the specified range.
* @param inputCount The number of inputs and outputs.
* @param compl True if the complement mode should be use.
* @param min The minimum value to use(i.e. 0 or -1)
* @param max The maximum value to use(i.e. 1 or 0)
* @return The training set.
*/
public static MLDataSet generateTraining(int inputCount, boolean compl, double min, double max) {
return generateTraining(inputCount,compl,min,max,min,max);
}
public static MLDataSet generateTraining(int inputCount, boolean compl, double inputMin, double inputMax, double outputMin, double outputMax) {
double[][] input = new double[inputCount][inputCount];
double[][] ideal = new double[inputCount][inputCount];
for (int i = 0; i < inputCount; i++) {
for (int j = 0; j < inputCount; j++) {
if (compl) {
input[i][j] = (j == i) ? inputMax : inputMin;
ideal[i][j] = (j == i) ? outputMin : outputMax;
} else {
input[i][j] = (j == i) ? inputMax : inputMin;
ideal[i][j] = (j == i) ? inputMax : inputMin;
}
}
}
return new BasicMLDataSet(input, ideal);
}
}