/**
* <summary> A constructor that takes {@link InstanceList}s as trainsSet and validationSet. It sets the {@link NeuralNetworkModel}
* nodes with given {@link InstanceList} then creates an input vector by using given trainSet and finds error.
* Via the validationSet it finds the classification performance and reassigns the allocated weight Matrix with the matrix
* that has the best accuracy and the Matrix V with the best Vector input.</summary>
*
* <param name="trainSet"> InstanceList that is used to train.</param>
* <param name="validationSet">InstanceList that is used to validate.</param>
* <param name="parameters"> Multi layer perceptron parameters; seed, learningRate, etaDecrease, crossValidationRatio, epoch, hiddenNodes.</param>
*/
public MultiLayerPerceptronModel(InstanceList.InstanceList trainSet, InstanceList.InstanceList validationSet,
MultiLayerPerceptronParameter parameters) : base(trainSet)
{
_activationFunction = parameters.GetActivationFunction();
AllocateWeights(parameters.GetHiddenNodes(), new Random(parameters.GetSeed()));
var bestW = (Matrix)W.Clone();
var bestV = (Matrix)_V.Clone();
var bestClassificationPerformance = new ClassificationPerformance(0.0);
var epoch = parameters.GetEpoch();
var learningRate = parameters.GetLearningRate();
var activationDerivative = new Vector(1, 0.0);
for (var i = 0; i < epoch; i++)
{
trainSet.Shuffle(parameters.GetSeed());
for (var j = 0; j < trainSet.Size(); j++)
{
CreateInputVector(trainSet.Get(j));
var hidden = CalculateHidden(x, W, _activationFunction);
var hiddenBiased = hidden.Biased();
var rMinusY = CalculateRMinusY(trainSet.Get(j), hiddenBiased, _V);
var deltaV = rMinusY.Multiply(hiddenBiased);
var tmph = _V.MultiplyWithVectorFromLeft(rMinusY);
tmph.Remove(0);
switch (_activationFunction)
{
case ActivationFunction.SIGMOID:
var oneMinusHidden = CalculateOneMinusHidden(hidden);
activationDerivative = oneMinusHidden.ElementProduct(hidden);
break;
case ActivationFunction.TANH:
var one = new Vector(hidden.Size(), 1.0);
hidden.Tanh();
activationDerivative = one.Difference(hidden.ElementProduct(hidden));
break;
case ActivationFunction.RELU:
hidden.ReluDerivative();
activationDerivative = hidden;
break;
}
var tmpHidden = tmph.ElementProduct(activationDerivative);
var deltaW = tmpHidden.Multiply(x);
deltaV.MultiplyWithConstant(learningRate);
_V.Add(deltaV);
deltaW.MultiplyWithConstant(learningRate);
W.Add(deltaW);
}
var currentClassificationPerformance = TestClassifier(validationSet);
if (currentClassificationPerformance.GetAccuracy() > bestClassificationPerformance.GetAccuracy())
{
bestClassificationPerformance = currentClassificationPerformance;
bestW = (Matrix)W.Clone();
bestV = (Matrix)_V.Clone();
}
learningRate *= parameters.GetEtaDecrease();
}
W = bestW;
_V = bestV;
}
/**
* <summary> A performance test for an auto encoder with the given test set..</summary>
*
* <param name="testSet">Test data (list of instances) to be tested.</param>
* <returns>Error rate.</returns>
*/
public override Performance.Performance Test(InstanceList.InstanceList testSet)
{
return(((AutoEncoderModel)model).TestAutoEncoder(testSet));
}
/**
* <summary> Constructor that sets the data {@link InstanceList}, k value and the {@link DistanceMetric}.</summary>
*
* <param name="data"> {@link InstanceList} input.</param>
* <param name="k"> K value.</param>
* <param name="distanceMetric">{@link DistanceMetric} input.</param>
*/
public KnnModel(InstanceList.InstanceList data, int k, DistanceMetric.DistanceMetric distanceMetric)
{
this._data = data;
this._k = k;
this._distanceMetric = distanceMetric;
}
/**
* <summary> Constructor which sets the distribution using the given {@link InstanceList}.</summary>
*
* <param name="trainSet">{@link InstanceList} which is used to get the class distribution.</param>
*/
public DummyModel(InstanceList.InstanceList trainSet)
{
this._distribution = trainSet.ClassDistribution();
}
/**
* <summary> Training algorithm for K-nearest neighbor classifier.</summary>
*
* <param name="trainSet"> Training data given to the algorithm.</param>
* <param name="parameters">K: k parameter of the K-nearest neighbor algorithm
* distanceMetric: distance metric used to calculate the distance between two instances.</param>
*/
public override void Train(InstanceList.InstanceList trainSet, Parameter.Parameter parameters)
{
model = new KnnModel(trainSet, ((KnnParameter)parameters).GetK(),
((KnnParameter)parameters).GetDistanceMetric());
}
/**
* <summary> Runs current classifier with the given train and test data.</summary>
*
* <param name="parameter">Parameter of the classifier to be trained.</param>
* <param name="trainSet"> Training data to be used in training the classifier.</param>
* <param name="testSet"> Test data to be tested after training the model.</param>
* <returns>The accuracy (and error) of the trained model as an instance of Performance class.</returns>
*/
public Performance.Performance SingleRun(Parameter.Parameter parameter, InstanceList.InstanceList trainSet,
InstanceList.InstanceList testSet)
{
Train(trainSet, parameter);
return(Test(testSet));
}
public abstract void Train(InstanceList.InstanceList trainSet, Parameter.Parameter parameters);
/**
* <summary> Training algorithm for random classifier.</summary>
*
* <param name="trainSet"> Training data given to the algorithm.</param>
* <param name="parameters">-</param>
*/
public override void Train(InstanceList.InstanceList trainSet, Parameter.Parameter parameters)
{
model = new RandomModel(new List <String>(trainSet.ClassDistribution().Keys), parameters.GetSeed());
}
/**
* <summary> Constructor that sets the {@link NeuralNetworkModel} nodes with given {@link InstanceList}.</summary>
*
* <param name="trainSet">InstanceList that is used to train.</param>
*/
public LinearPerceptronModel(InstanceList.InstanceList trainSet) : base(trainSet)
{
}
/**
* <summary> Training algorithm for C4.5 Stump univariate decision tree classifier.</summary>
*
* <param name="trainSet"> Training data given to the algorithm.</param>
* <param name="parameters">-</param>
*/
public override void Train(InstanceList.InstanceList trainSet, Parameter.Parameter parameters)
{
model = new DecisionTree(new DecisionNode(trainSet, null, null, true));
}
