public QuickPropagation(IContainsFlat network, IMLDataSet training, double learnRate)
: base(network, training)
{
ValidateNetwork.ValidateMethodToData(network, training);
TrainFlatNetworkQPROP kqprop = new TrainFlatNetworkQPROP(network.Flat, this.Training, learnRate);
base.FlatTraining = kqprop;
}
/// <summary>
/// Construct a training class.
/// </summary>
///
/// <param name="network">The network to train.</param>
/// <param name="training">The training data.</param>
public ScaledConjugateGradient(IContainsFlat network,
IMLDataSet training) : base(network, training)
{
var rpropFlat = new TrainFlatNetworkSCG(
network.Flat, Training);
FlatTraining = rpropFlat;
}
/// <summary>
/// Construct a Manhattan propagation training object.
/// </summary>
///
/// <param name="network">The network to train.</param>
/// <param name="training">The training data to use.</param>
/// <param name="learnRate">The learning rate.</param>
public ManhattanPropagation(IContainsFlat network,
IMLDataSet training, double learnRate)
: base(network, training)
{
_learningRate = learnRate;
_zeroTolerance = RPROPConst.DefaultZeroTolerance;
}
public Backpropagation(IContainsFlat network, IMLDataSet training, double learnRate, double momentum)
: base(network, training)
{
ValidateNetwork.ValidateMethodToData(network, training);
TrainFlatNetworkBackPropagation propagation = new TrainFlatNetworkBackPropagation(network.Flat, this.Training, learnRate, momentum);
base.FlatTraining = propagation;
}
/// <summary>
/// Construct a QPROP trainer for flat networks.
/// </summary>
/// <param name="network">The network to train.</param>
/// <param name="training">The training data.</param>
/// <param name="learnRate">The learning rate. 2 is a good suggestion as
/// a learning rate to start with. If it fails to converge,
/// then drop it. Just like backprop, except QPROP can
/// take higher learning rates.</param>
public QuickPropagation(IContainsFlat network,
IMLDataSet training, double learnRate) : base(network, training)
{
ValidateNetwork.ValidateMethodToData(network, training);
LearningRate = learnRate;
LastDelta = new double[Network.Flat.Weights.Length];
OutputEpsilon = 1.0;
}
/**
*
*
* @param network
*
* @param training
*
* @param theLearningRate
*
*/
/// <summary>
/// Construct a QPROP trainer for flat networks.
/// </summary>
/// <param name="network">The network to train.</param>
/// <param name="training">The training data.</param>
/// <param name="learnRate">The learning rate. 2 is a good suggestion as
/// a learning rate to start with. If it fails to converge,
/// then drop it. Just like backprop, except QPROP can
/// take higher learning rates.</param>
public QuickPropagation(IContainsFlat network,
IMLDataSet training, double learnRate) : base(network, training)
{
ValidateNetwork.ValidateMethodToData(network, training);
var backFlat = new TrainFlatNetworkQPROP(
network.Flat, Training, learnRate);
FlatTraining = backFlat;
}
/// <summary>
/// Construct a training class.
/// </summary>
///
/// <param name="network">The network to train.</param>
/// <param name="training">The training data.</param>
public ScaledConjugateGradient(IContainsFlat network,
IMLDataSet training) : base(network, training)
{
var rpropFlat = new TrainFlatNetworkSCG(
network.Flat, Training);
FlatTraining = rpropFlat;
}
/// <summary>
/// Construct a QPROP trainer for flat networks.
/// </summary>
/// <param name="network">The network to train.</param>
/// <param name="training">The training data.</param>
/// <param name="learnRate">The learning rate. 2 is a good suggestion as
/// a learning rate to start with. If it fails to converge,
/// then drop it. Just like backprop, except QPROP can
/// take higher learning rates.</param>
public QuickPropagation(IContainsFlat network,
IMLDataSet training, double learnRate)
: base(network, training)
{
ValidateNetwork.ValidateMethodToData(network, training);
LearningRate = learnRate;
LastDelta = new double[Network.Flat.Weights.Length];
OutputEpsilon = 1.0;
}
/// <param name="network">The network that is to be trained</param>
/// <param name="training">The training set</param>
/// <param name="learnRate"></param>
/// <param name="momentum"></param>
public Backpropagation(IContainsFlat network,
IMLDataSet training, double learnRate,
double momentum) : base(network, training)
{
ValidateNetwork.ValidateMethodToData(network, training);
var backFlat = new TrainFlatNetworkBackPropagation(
network.Flat, Training, learnRate, momentum);
FlatTraining = backFlat;
}
/**
*
*
* @param network
*
* @param training
*
* @param theLearningRate
*
*/
/// <summary>
/// Construct a QPROP trainer for flat networks.
/// </summary>
/// <param name="network">The network to train.</param>
/// <param name="training">The training data.</param>
/// <param name="learnRate">The learning rate. 2 is a good suggestion as
/// a learning rate to start with. If it fails to converge,
/// then drop it. Just like backprop, except QPROP can
/// take higher learning rates.</param>
public QuickPropagation(IContainsFlat network,
IMLDataSet training, double learnRate) : base(network, training)
{
ValidateNetwork.ValidateMethodToData(network, training);
var backFlat = new TrainFlatNetworkQPROP(
network.Flat, Training, learnRate);
FlatTraining = backFlat;
}
/// <param name="network">The network that is to be trained</param>
/// <param name="training">The training set</param>
/// <param name="learnRate"></param>
/// <param name="momentum"></param>
public Backpropagation(IContainsFlat network,
IMLDataSet training, double learnRate,
double momentum) : base(network, training)
{
ValidateNetwork.ValidateMethodToData(network, training);
_momentum = momentum;
_learningRate = learnRate;
_lastDelta = new double[Network.Flat.Weights.Length];
}
/// <summary>
/// Construct a resilient training object, allow the training parameters to
/// be specified. Usually the default parameters are acceptable for the
/// resilient training algorithm. Therefore you should usually use the other
/// constructor, that makes use of the default values.
/// </summary>
///
/// <param name="network">The network to train.</param>
/// <param name="training">The training set to use.</param>
/// <param name="initialUpdate"></param>
/// <param name="maxStep">The maximum that a delta can reach.</param>
public ResilientPropagation(IContainsFlat network,
IMLDataSet training, double initialUpdate,
double maxStep) : base(network, training)
{
var rpropFlat = new TrainFlatNetworkResilient(
network.Flat, Training,
RPROPConst.DefaultZeroTolerance, initialUpdate, maxStep);
FlatTraining = rpropFlat;
}
/// <param name="network">The network that is to be trained</param>
/// <param name="training">The training set</param>
/// <param name="learnRate"></param>
/// <param name="momentum"></param>
public Backpropagation(IContainsFlat network,
IMLDataSet training, double learnRate,
double momentum) : base(network, training)
{
ValidateNetwork.ValidateMethodToData(network, training);
var backFlat = new TrainFlatNetworkBackPropagation(
network.Flat, Training, learnRate, momentum);
FlatTraining = backFlat;
}
/// <summary>
/// Construct a resilient training object, allow the training parameters to
/// be specified. Usually the default parameters are acceptable for the
/// resilient training algorithm. Therefore you should usually use the other
/// constructor, that makes use of the default values.
/// </summary>
///
/// <param name="network">The network to train.</param>
/// <param name="training">The training set to use.</param>
/// <param name="initialUpdate"></param>
/// <param name="maxStep">The maximum that a delta can reach.</param>
public ResilientPropagation(IContainsFlat network,
IMLDataSet training, double initialUpdate,
double maxStep) : base(network, training)
{
_updateValues = new double[network.Flat.Weights.Length];
_zeroTolerance = RPROPConst.DefaultZeroTolerance;
_maxStep = maxStep;
_lastWeightChanged = new double[Network.Flat.Weights.Length];
_lastDelta = new double[Network.Flat.Weights.Length];
for (int i = 0; i < _updateValues.Length; i++)
{
_updateValues[i] = initialUpdate;
}
}
/// <summary>
/// Construct a propagation object.
/// </summary>
///
/// <param name="network">The network.</param>
/// <param name="training">The training set.</param>
protected Propagation(IContainsFlat network, IMLDataSet training) : base(TrainingImplementationType.Iterative)
{
_network = network;
_flat = network.Flat;
_training = training;
Gradients = new double[_flat.Weights.Length];
_lastGradient = new double[_flat.Weights.Length];
_indexable = training;
_numThreads = 0;
_reportedException = null;
FixFlatSpot = true;
ErrorFunction = new LinearErrorFunction();
}
public StochasticGradientDescent(IContainsFlat network,
IMLDataSet training, IGenerateRandom theRandom) :
base(TrainingImplementationType.Iterative)
{
Training = training;
UpdateRule = new AdamUpdate();
if (!(training is BatchDataSet))
{
BatchSize = 25;
}
_method = network;
_flat = network.Flat;
_layerDelta = new double[_flat.LayerOutput.Length];
_gradients = new double[_flat.Weights.Length];
_errorCalculation = new ErrorCalculation();
_rnd = theRandom;
LearningRate = 0.001;
Momentum = 0.9;
}
/// <summary>
/// Validate a network for training.
/// </summary>
///
/// <param name="network">The network to validate.</param>
/// <param name="training">The training set to validate.</param>
public static void ValidateNetworkForTraining(IContainsFlat network,
IMLDataSet training)
{
int inputCount = network.Flat.InputCount;
int outputCount = network.Flat.OutputCount;
if (inputCount != training.InputSize)
{
throw new NeuralNetworkError("The input layer size of "
+ inputCount + " must match the training input size of "
+ training.InputSize + ".");
}
if ((training.IdealSize > 0) &&
(outputCount != training.IdealSize))
{
throw new NeuralNetworkError("The output layer size of "
+ outputCount + " must match the training input size of "
+ training.IdealSize + ".");
}
}
/// <summary>
/// Validate a network for training.
/// </summary>
///
/// <param name="network">The network to validate.</param>
/// <param name="training">The training set to validate.</param>
public static void ValidateNetworkForTraining(IContainsFlat network,
IMLDataSet training)
{
int inputCount = network.Flat.InputCount;
int outputCount = network.Flat.OutputCount;
if (inputCount != training.InputSize)
{
throw new NeuralNetworkError("The input layer size of "
+ inputCount + " must match the training input size of "
+ training.InputSize + ".");
}
if ((training.IdealSize > 0)
&& (outputCount != training.IdealSize))
{
throw new NeuralNetworkError("The output layer size of "
+ outputCount + " must match the training input size of "
+ training.IdealSize + ".");
}
}
/// <summary>
/// Construct a training class.
/// </summary>
///
/// <param name="network">The network to train.</param>
/// <param name="training">The training data.</param>
public ScaledConjugateGradient(IContainsFlat network,
IMLDataSet training) : base(network, training)
{
_success = true;
_success = true;
_delta = 0;
_lambda2 = 0;
_lambda = FirstLambda;
_oldError = 0;
_magP = 0;
_restart = false;
_weights = EngineArray.ArrayCopy(network.Flat.Weights);
int numWeights = _weights.Length;
_oldWeights = new double[numWeights];
_oldGradient = new double[numWeights];
_p = new double[numWeights];
_r = new double[numWeights];
_mustInit = true;
}
public static void ValidateNetworkForTraining(IContainsFlat network, IMLDataSet training)
{
int num2;
object[] objArray;
object[] objArray2;
int inputCount = network.Flat.InputCount;
if (((uint) num2) <= uint.MaxValue)
{
Label_01D4:
num2 = network.Flat.OutputCount;
if (inputCount != training.InputSize)
{
objArray = new object[5];
objArray[0] = "The input layer size of ";
if (15 != 0)
{
objArray[1] = inputCount;
goto Label_0187;
}
goto Label_01D4;
}
if ((((uint) num2) - ((uint) inputCount)) >= 0)
{
goto Label_008F;
}
goto Label_0098;
}
goto Label_0187;
Label_0088:
if (-2 != 0)
{
goto Label_0098;
}
Label_008F:
if (training.IdealSize <= 0)
{
if ((((uint) inputCount) + ((uint) inputCount)) <= uint.MaxValue)
{
return;
}
goto Label_0088;
}
Label_0098:
if (num2 != training.IdealSize)
{
objArray2 = new object[5];
objArray2[0] = "The output layer size of ";
}
else
{
return;
if ((((uint) num2) + ((uint) inputCount)) <= uint.MaxValue)
{
goto Label_0088;
}
goto Label_008F;
}
Label_00ED:
objArray2[1] = num2;
objArray2[2] = " must match the training input size of ";
objArray2[3] = training.IdealSize;
objArray2[4] = ".";
throw new NeuralNetworkError(string.Concat(objArray2));
if ((((uint) num2) | uint.MaxValue) != 0)
{
return;
}
if ((((uint) inputCount) & 0) == 0)
{
goto Label_0187;
}
Label_013A:
objArray[3] = training.InputSize;
objArray[4] = ".";
throw new NeuralNetworkError(string.Concat(objArray));
Label_0187:
if ((((uint) inputCount) + ((uint) num2)) > uint.MaxValue)
{
goto Label_00ED;
}
objArray[2] = " must match the training input size of ";
goto Label_013A;
}
/// <param name="network">The network that is to be trained</param>
/// <param name="training">The training set</param>
/// <param name="learnRate"></param>
/// <param name="momentum"></param>
public Backpropagation(IContainsFlat network,
IMLDataSet training, double learnRate,
double momentum)
: base(network, training)
{
ValidateNetwork.ValidateMethodToData(network, training);
_momentum = momentum;
_learningRate = learnRate;
_lastDelta = new double[Network.Flat.Weights.Length];
}
/// <summary>
/// Create a class to train using backpropagation. Use auto learn rate and
/// momentum. Use the CPU to train.
/// </summary>
///
/// <param name="network">The network that is to be trained.</param>
/// <param name="training">The training data to be used for backpropagation.</param>
public Backpropagation(IContainsFlat network, IMLDataSet training)
: this(network, training, 0, 0)
{
AddStrategy(new SmartLearningRate());
AddStrategy(new SmartMomentum());
}
/// <summary>
/// Construct a propagation object.
/// </summary>
///
/// <param name="network">The network.</param>
/// <param name="training">The training set.</param>
protected Propagation(IContainsFlat network, IMLDataSet training) : base(TrainingImplementationType.Iterative)
{
_network = network;
Training = training;
}
public ResilientPropagation(IContainsFlat network, IMLDataSet training)
: this(network, training, 0.1, 50.0)
{
}
/// <summary>
/// Construct a resilient training object, allow the training parameters to
/// be specified. Usually the default parameters are acceptable for the
/// resilient training algorithm. Therefore you should usually use the other
/// constructor, that makes use of the default values.
/// </summary>
///
/// <param name="network">The network to train.</param>
/// <param name="training">The training set to use.</param>
/// <param name="initialUpdate"></param>
/// <param name="maxStep">The maximum that a delta can reach.</param>
public ResilientPropagation(IContainsFlat network,
IMLDataSet training, double initialUpdate,
double maxStep)
: base(network, training)
{
_updateValues = new double[network.Flat.Weights.Length];
_zeroTolerance = RPROPConst.DefaultZeroTolerance;
_maxStep = maxStep;
_lastWeightChanged = new double[Network.Flat.Weights.Length];
_lastDelta = new double[Network.Flat.Weights.Length];
for (int i = 0; i < _updateValues.Length; i++)
{
_updateValues[i] = initialUpdate;
}
}
protected Propagation(IContainsFlat network, IMLDataSet training)
: base(TrainingImplementationType.Iterative)
{
this._x87a7fc6a72741c2e = network;
this.Training = training;
}
/// <summary>
/// Construct an RPROP trainer, allows an OpenCL device to be specified. Use
/// the defaults for all training parameters. Usually this is the constructor
/// to use as the resilient training algorithm is designed for the default
/// parameters to be acceptable for nearly all problems.
/// </summary>
///
/// <param name="network">The network to train.</param>
/// <param name="training">The training data to use.</param>
public ResilientPropagation(IContainsFlat network,
IMLDataSet training)
: this(network, training, RPROPConst.DefaultInitialUpdate, RPROPConst.DefaultMaxStep)
{
}
/// <summary>
/// Construct a QPROP trainer for flat networks. Uses a learning rate of 2.
/// </summary>
/// <param name="network">The network to train.</param>
/// <param name="training">The training data.</param>
public QuickPropagation(IContainsFlat network, IMLDataSet training) : this(network, training, 2.0)
{
}
public ITrain TrainNetwork(IContainsFlat network, IMLDataSet trainingSet)
{
return(new Backpropagation(network, trainingSet, learningRate, momentum));
}
public ScaledConjugateGradient(IContainsFlat network, IMLDataSet training)
: base(network, training)
{
TrainFlatNetworkSCG kscg = new TrainFlatNetworkSCG(network.Flat, this.Training);
base.FlatTraining = kscg;
}
/// <summary>
/// Construct a training class.
/// </summary>
///
/// <param name="network">The network to train.</param>
/// <param name="training">The training data.</param>
public ScaledConjugateGradient(IContainsFlat network,
IMLDataSet training)
: base(network, training)
{
_success = true;
_success = true;
_delta = 0;
_lambda2 = 0;
_lambda = FirstLambda;
_oldError = 0;
_magP = 0;
_restart = false;
_weights = EngineArray.ArrayCopy(network.Flat.Weights);
int numWeights = _weights.Length;
_oldWeights = new double[numWeights];
_oldGradient = new double[numWeights];
_p = new double[numWeights];
_r = new double[numWeights];
_mustInit = true;
}
/// <summary>
/// Construct a Manhattan propagation training object.
/// </summary>
///
/// <param name="network">The network to train.</param>
/// <param name="training">The training data to use.</param>
/// <param name="learnRate">The learning rate.</param>
public ManhattanPropagation(IContainsFlat network,
IMLDataSet training, double learnRate) : base(network, training)
{
FlatTraining = new TrainFlatNetworkManhattan(network.Flat,
Training, learnRate);
}
/// <summary>
/// Construct a Manhattan propagation training object.
/// </summary>
///
/// <param name="network">The network to train.</param>
/// <param name="training">The training data to use.</param>
/// <param name="learnRate">The learning rate.</param>
public ManhattanPropagation(IContainsFlat network,
IMLDataSet training, double learnRate) : base(network, training)
{
FlatTraining = new TrainFlatNetworkManhattan(network.Flat,
Training, learnRate);
}
/// <summary>
/// Construct a QPROP trainer for flat networks. Uses a learning rate of 2.
/// </summary>
/// <param name="network">The network to train.</param>
/// <param name="training">The training data.</param>
public QuickPropagation(IContainsFlat network, IMLDataSet training) : this(network, training, 2.0)
{
}
/// <summary>
/// Construct a Manhattan propagation training object.
/// </summary>
///
/// <param name="network">The network to train.</param>
/// <param name="training">The training data to use.</param>
/// <param name="learnRate">The learning rate.</param>
public ManhattanPropagation(IContainsFlat network,
IMLDataSet training, double learnRate) : base(network, training)
{
_learningRate = learnRate;
_zeroTolerance = RPROPConst.DefaultZeroTolerance;
}
/// <summary>
/// Construct a resilient training object, allow the training parameters to
/// be specified. Usually the default parameters are acceptable for the
/// resilient training algorithm. Therefore you should usually use the other
/// constructor, that makes use of the default values.
/// </summary>
///
/// <param name="network">The network to train.</param>
/// <param name="training">The training set to use.</param>
/// <param name="initialUpdate"></param>
/// <param name="maxStep">The maximum that a delta can reach.</param>
public ResilientPropagation(IContainsFlat network,
IMLDataSet training, double initialUpdate,
double maxStep) : base(network, training)
{
var rpropFlat = new TrainFlatNetworkResilient(
network.Flat, Training,
RPROPConst.DefaultZeroTolerance, initialUpdate, maxStep);
FlatTraining = rpropFlat;
}
public ITrain TrainNetwork(IContainsFlat network, IMLDataSet trainingSet)
{
return(new Encog.Neural.Networks.Training.Propagation.Resilient.ResilientPropagation(network, trainingSet));
}
/// <summary>
/// Construct a propagation object.
/// </summary>
///
/// <param name="network">The network.</param>
/// <param name="training">The training set.</param>
protected Propagation(IContainsFlat network, IMLDataSet training) : base(TrainingImplementationType.Iterative)
{
_network = network;
Training = training;
}
/// <summary>
/// Create a class to train using backpropagation. Use auto learn rate and
/// momentum. Use the CPU to train.
/// </summary>
///
/// <param name="network">The network that is to be trained.</param>
/// <param name="training">The training data to be used for backpropagation.</param>
public Backpropagation(IContainsFlat network, IMLDataSet training) : this(network, training, 0, 0)
{
AddStrategy(new SmartLearningRate());
AddStrategy(new SmartMomentum());
}
public ResilientPropagation(IContainsFlat network, IMLDataSet training, double initialUpdate, double maxStep)
: base(network, training)
{
TrainFlatNetworkResilient resilient = new TrainFlatNetworkResilient(network.Flat, this.Training, 1E-17, initialUpdate, maxStep);
base.FlatTraining = resilient;
}
/// <summary>
/// Construct an RPROP trainer, allows an OpenCL device to be specified. Use
/// the defaults for all training parameters. Usually this is the constructor
/// to use as the resilient training algorithm is designed for the default
/// parameters to be acceptable for nearly all problems.
/// </summary>
///
/// <param name="network">The network to train.</param>
/// <param name="training">The training data to use.</param>
public ResilientPropagation(IContainsFlat network,
IMLDataSet training)
: this(network, training, RPROPConst.DefaultInitialUpdate, RPROPConst.DefaultMaxStep)
{
}
public StochasticGradientDescent(IContainsFlat network,
IMLDataSet training) :
this(network, training, new MersenneTwisterGenerateRandom())
{
}
/// <summary>
/// Construct a propagation object.
/// </summary>
///
/// <param name="network">The network.</param>
/// <param name="training">The training set.</param>
protected Propagation(IContainsFlat network, IMLDataSet training)
: base(TrainingImplementationType.Iterative)
{
_network = network;
_flat = network.Flat;
_training = training;
Gradients = new double[_flat.Weights.Length];
_lastGradient = new double[_flat.Weights.Length];
_indexable = training;
_numThreads = 0;
_reportedException = null;
FixFlatSpot = true;
ErrorFunction = new LinearErrorFunction();
}