26 RegisterRegressifierModule< MLP > MLP::registerModule(
"MLP");
29 inputLayerActivationFunction = Neuron::LINEAR;
30 hiddenLayerActivationFunction = Neuron::LINEAR;
31 outputLayerActivationFunction = Neuron::LINEAR;
33 numRandomTrainingIterations = 10;
34 validationSetSize = 20;
35 trainingMode = ONLINE_GRADIENT_DESCENT;
39 nullRejectionCoeff = 0.9;
40 nullRejectionThreshold = 0;
41 useValidationSet =
true;
42 randomiseTrainingOrder =
false;
46 classificationModeActive =
false;
47 useNullRejection =
true;
50 regressifierType = classType;
51 debugLog.setProceedingText(
"[DEBUG MLP]");
52 errorLog.setProceedingText(
"[ERROR MLP]");
53 trainingLog.setProceedingText(
"[TRAINING MLP]");
54 warningLog.setProceedingText(
"[WARNING MLP]");
59 regressifierType = classType;
60 debugLog.setProceedingText(
"[DEBUG MLP]");
61 errorLog.setProceedingText(
"[ERROR MLP]");
62 trainingLog.setProceedingText(
"[TRAINING MLP]");
63 warningLog.setProceedingText(
"[WARNING MLP]");
75 this->numInputNeurons = rhs.numInputNeurons;
76 this->numHiddenNeurons = rhs.numHiddenNeurons;
77 this->numOutputNeurons = rhs.numOutputNeurons;
78 this->inputLayerActivationFunction = rhs.inputLayerActivationFunction;
79 this->hiddenLayerActivationFunction = rhs.hiddenLayerActivationFunction;
80 this->outputLayerActivationFunction = rhs.outputLayerActivationFunction;
81 this->numRandomTrainingIterations = rhs.numRandomTrainingIterations;
82 this->trainingMode = rhs.trainingMode;
83 this->momentum = rhs.momentum;
84 this->trainingError = rhs.trainingError;
85 this->gamma = rhs.gamma;
86 this->initialized = rhs.initialized;
87 this->inputLayer = rhs.inputLayer;
88 this->hiddenLayer = rhs.hiddenLayer;
89 this->outputLayer = rhs.outputLayer;
90 this->inputVectorRanges = rhs.inputVectorRanges;
91 this->targetVectorRanges = rhs.targetVectorRanges;
92 this->trainingErrorLog = rhs.trainingErrorLog;
94 this->classificationModeActive = rhs.classificationModeActive;
95 this->useNullRejection = rhs.useNullRejection;
96 this->predictedClassLabel = rhs.predictedClassLabel;
97 this->nullRejectionCoeff = rhs.nullRejectionCoeff;
98 this->nullRejectionThreshold = rhs.nullRejectionThreshold;
99 this->maxLikelihood = rhs.maxLikelihood;
100 this->classLikelihoods = rhs.classLikelihoods;
110 if( regressifier == NULL ){
111 errorLog <<
"deepCopyFrom(const Regressifier *regressifier) - regressifier is NULL!" << endl;
116 errorLog <<
"deepCopyFrom(const Regressifier *regressifier) - regressifier is not the correct type!" << endl;
120 *
this = *
dynamic_cast<const MLP*
>(regressifier);
129 errorLog <<
"train_(ClassificationData trainingData) - The MLP has not been initialized!" << endl;
134 errorLog <<
"train_(ClassificationData trainingData) - The number of input dimensions in the training data (" << trainingData.
getNumDimensions() <<
") does not match that of the MLP (" << numInputNeurons <<
")" << endl;
138 errorLog <<
"train_(ClassificationData trainingData) - The number of classes in the training data (" << trainingData.
getNumClasses() <<
") does not match that of the MLP (" << numOutputNeurons <<
")" << endl;
146 classificationModeActive =
true;
148 return trainModel(regressionData);
154 classificationModeActive =
false;
156 return trainModel(trainingData);
163 errorLog <<
"predict_(VectorDouble &inputVector) - Model not trained!" << endl;
167 if( inputVector.size() != numInputNeurons ){
168 errorLog <<
"predict_(VectorDouble &inputVector) - The sie of the input vector (" << int(inputVector.size()) <<
") does not match that of the number of input dimensions (" << numInputNeurons <<
") " << endl;
175 if( classificationModeActive ){
178 const UINT K = (UINT)regressionData.size();
179 classLikelihoods = regressionData;
183 for(UINT i=0; i<K; i++){
184 classLikelihoods[i] += minValue;
188 double sum =
Util::sum(classLikelihoods);
190 for(UINT i=0; i<K; i++){
191 classLikelihoods[i] /= sum;
196 double bestValue = classLikelihoods[0];
198 for(UINT i=1; i<K; i++){
199 if( classLikelihoods[i] > bestValue ){
200 bestValue = classLikelihoods[i];
206 maxLikelihood = bestValue;
207 predictedClassLabel = bestIndex+1;
209 if( useNullRejection ){
210 if( maxLikelihood < nullRejectionCoeff ){
211 predictedClassLabel = 0;
219 bool MLP::init(
const UINT numInputNeurons,
const UINT numHiddenNeurons,
const UINT numOutputNeurons){
220 return init(numInputNeurons, numHiddenNeurons, numOutputNeurons, inputLayerActivationFunction, hiddenLayerActivationFunction, outputLayerActivationFunction );
224 const UINT numHiddenNeurons,
225 const UINT numOutputNeurons,
226 const UINT inputLayerActivationFunction,
227 const UINT hiddenLayerActivationFunction,
228 const UINT outputLayerActivationFunction){
234 random.
setSeed( (UINT)time(NULL) );
236 if( numInputNeurons == 0 || numHiddenNeurons == 0 || numOutputNeurons == 0 ){
237 if( numInputNeurons == 0 ){ errorLog <<
"init(...) - The number of input neurons is zero!" << endl; }
238 if( numHiddenNeurons == 0 ){ errorLog <<
"init(...) - The number of hidden neurons is zero!" << endl; }
239 if( numOutputNeurons == 0 ){ errorLog <<
"init(...) - The number of output neurons is zero!" << endl; }
245 errorLog <<
"init(...) - One Of The Activation Functions Failed The Validation Check" << endl;
250 this->numInputNeurons = numInputNeurons;
251 this->numHiddenNeurons = numHiddenNeurons;
252 this->numOutputNeurons = numOutputNeurons;
255 this->numInputDimensions = numInputNeurons;
256 this->numOutputDimensions = numOutputNeurons;
259 this->inputLayerActivationFunction = inputLayerActivationFunction;
260 this->hiddenLayerActivationFunction = hiddenLayerActivationFunction;
261 this->outputLayerActivationFunction = outputLayerActivationFunction;
264 inputLayer.resize(numInputNeurons);
265 hiddenLayer.resize(numHiddenNeurons);
266 outputLayer.resize(numOutputNeurons);
269 for(UINT i=0; i<numInputNeurons; i++){
270 inputLayer[i].init(1,inputLayerActivationFunction);
271 inputLayer[i].weights[0] = 1.0;
272 inputLayer[i].bias = 0.0;
273 inputLayer[i].gamma = gamma;
276 for(UINT i=0; i<numHiddenNeurons; i++){
277 hiddenLayer[i].init(numInputNeurons,hiddenLayerActivationFunction);
278 hiddenLayer[i].gamma = gamma;
281 for(UINT i=0; i<numOutputNeurons; i++){
282 outputLayer[i].init(numHiddenNeurons,outputLayerActivationFunction);
283 outputLayer[i].gamma = gamma;
297 numHiddenNeurons = 0;
298 numOutputNeurons = 0;
317 errorLog <<
"train(RegressionData trainingData) - The MLP has not be initialized!" << endl;
322 errorLog <<
"train(RegressionData trainingData) - The training data is empty!" << endl;
327 RegressionData validationData;
328 if( useValidationSet ){
329 validationData = trainingData.
partition( 100 - validationSetSize );
335 if( N != numInputNeurons ){
336 errorLog <<
"train(LabelledRegressionData trainingData) - The number of input dimensions in the training data (" << N <<
") does not match that of the MLP (" << numInputNeurons <<
")" << endl;
339 if( T != numOutputNeurons ){
340 errorLog <<
"train(LabelledRegressionData trainingData) - The number of target dimensions in the training data (" << T <<
") does not match that of the MLP (" << numOutputNeurons <<
")" << endl;
345 numInputDimensions = numInputNeurons;
346 numOutputDimensions = numOutputNeurons;
357 trainingData.
scale(inputVectorRanges,targetVectorRanges,0.0,1.0);
359 if( useValidationSet ){
360 validationData.scale(inputVectorRanges,targetVectorRanges,0.0,1.0);
365 bool tempScalingState = useScaling;
369 trainingErrorLog.clear();
370 inputNeuronsOuput.resize(numInputNeurons);
371 hiddenNeuronsOutput.resize(numHiddenNeurons);
372 outputNeuronsOutput.resize(numOutputNeurons);
373 deltaO.resize(numOutputNeurons);
374 deltaH.resize(numHiddenNeurons);
377 switch( trainingMode ){
378 case ONLINE_GRADIENT_DESCENT:
379 if( classificationModeActive ){
380 trained = trainOnlineGradientDescentClassification( trainingData, validationData );
382 trained = trainOnlineGradientDescentRegression( trainingData, validationData );
386 useScaling = tempScalingState;
387 errorLog <<
"train(RegressionData trainingData) - Uknown training mode!" << endl;
393 useScaling = tempScalingState;
398 bool MLP::trainOnlineGradientDescentClassification(
const RegressionData &trainingData,
const RegressionData &validationData){
400 const UINT M = trainingData.getNumSamples();
401 const UINT T = trainingData.getNumTargetDimensions();
402 const UINT numTestingExamples = useValidationSet ? validationData.getNumSamples() : M;
405 bool keepTraining =
true;
407 double alpha = learningRate;
408 double beta = momentum;
411 totalSquaredTrainingError = 0;
412 rootMeanSquaredTrainingError = 0;
415 double lastError = 0;
417 double trainingSetAccuracy = 0;
418 double trainingSetTotalSquaredError = 0;
419 double bestError = numeric_limits< double >::max();
420 double bestTSError = numeric_limits< double >::max();
421 double bestRMSError = numeric_limits< double >::max();
422 double bestAccuracy = 0;
424 vector< UINT > indexList(M);
425 vector< vector< double > > tempTrainingErrorLog;
426 TrainingResult result;
427 trainingResults.reserve(M);
430 for(UINT i=0; i<M; i++) indexList[i] = i;
432 for(UINT iter=0; iter<numRandomTrainingIterations; iter++){
436 tempTrainingErrorLog.clear();
439 init(numInputNeurons,numHiddenNeurons,numOutputNeurons,inputLayerActivationFunction,hiddenLayerActivationFunction,outputLayerActivationFunction);
441 if( randomiseTrainingOrder ){
442 for(UINT i=0; i<M; i++){
447 while( keepTraining ){
451 totalSquaredTrainingError = 0;
453 for(UINT i=0; i<M; i++){
455 const VectorDouble &trainingExample = trainingData[ indexList[i] ].getInputVector();
456 const VectorDouble &targetVector = trainingData[ indexList[i] ].getTargetVector();
459 double backPropError =
back_prop(trainingExample,targetVector,alpha,beta);
463 if( isNAN(backPropError) ){
464 keepTraining =
false;
465 errorLog <<
"train(LabelledRegressionData trainingData) - NaN found!" << endl;
469 if( classificationModeActive ){
473 double bestValue = targetVector[0];
475 for(UINT i=1; i<targetVector.size(); i++){
476 if( targetVector[i] > bestValue ){
477 bestValue = targetVector[i];
481 UINT classLabel = bestIndex + 1;
486 for(UINT i=1; i<numOutputNeurons; i++){
487 if( y[i] > bestValue ){
492 predictedClassLabel = bestIndex+1;
494 if( classLabel == predictedClassLabel ){
499 totalSquaredTrainingError += backPropError;
504 keepTraining =
false;
505 errorLog <<
"train(LabelledRegressionData trainingData) - NaN found!" << endl;
510 if( useValidationSet ){
511 trainingSetAccuracy = accuracy;
512 trainingSetTotalSquaredError = totalSquaredTrainingError;
514 totalSquaredTrainingError = 0;
517 UINT numValidationSamples = validationData.getNumSamples();
518 for(UINT i=0; i<numValidationSamples; i++){
519 const VectorDouble &trainingExample = validationData[i].getInputVector();
520 const VectorDouble &targetVector = validationData[i].getTargetVector();
524 if( classificationModeActive ){
526 double bestValue = targetVector[0];
528 for(UINT i=1; i<numInputNeurons; i++){
529 if( targetVector[i] > bestValue ){
530 bestValue = targetVector[i];
534 UINT classLabel = bestIndex + 1;
539 for(UINT i=1; i<numOutputNeurons; i++){
540 if( y[i] > bestValue ){
545 predictedClassLabel = bestIndex+1;
547 if( classLabel == predictedClassLabel ){
553 for(UINT j=0; j<T; j++){
554 totalSquaredTrainingError += SQR( targetVector[j]-y[j] );
559 accuracy = (accuracy/double(numValidationSamples))*
double(numValidationSamples);
560 rootMeanSquaredTrainingError = sqrt( totalSquaredTrainingError /
double(numValidationSamples) );
563 accuracy = (accuracy/double(M))*
double(M);
564 rootMeanSquaredTrainingError = sqrt( totalSquaredTrainingError /
double(M) );
568 VectorDouble temp(2);
569 temp[0] = 100.0 - trainingSetAccuracy;
570 temp[1] = 100.0 - accuracy;
571 tempTrainingErrorLog.push_back( temp );
573 error = 100.0 - accuracy;
576 result.setClassificationResult(iter,accuracy,
this);
577 trainingResults.push_back( result );
579 delta = fabs( error - lastError );
581 trainingLog <<
"Random Training Iteration: " << iter+1 <<
" Epoch: " << epoch <<
" Error: " << error <<
" Delta: " << delta << endl;
584 if( ++epoch >= maxNumEpochs ){
585 keepTraining =
false;
587 if( delta <= minChange && epoch >= minNumEpochs ){
588 keepTraining =
false;
595 trainingResultsObserverManager.notifyObservers( result );
599 if( lastError < bestError ){
601 bestError = lastError;
602 bestTSError = totalSquaredTrainingError;
603 bestRMSError = rootMeanSquaredTrainingError;
604 bestAccuracy = accuracy;
606 trainingErrorLog = tempTrainingErrorLog;
611 trainingLog <<
"Best Accuracy: " << bestAccuracy <<
" in Random Training Iteration: " << bestIter+1 << endl;
615 errorLog <<
"train(LabelledRegressionData trainingData) - NAN Found!" << endl;
621 trainingError = bestAccuracy;
624 double averageValue = 0;
625 VectorDouble classificationPredictions;
627 for(UINT i=0; i<numTestingExamples; i++){
628 VectorDouble inputVector = useValidationSet ? validationData[i].getInputVector() : trainingData[i].getInputVector();
629 VectorDouble targetVector = useValidationSet ? validationData[i].getTargetVector() : trainingData[i].getTargetVector();
635 double bestValue = targetVector[0];
637 for(UINT i=1; i<targetVector.size(); i++){
638 if( targetVector[i] > bestValue ){
639 bestValue = targetVector[i];
643 UINT classLabel = bestIndex + 1;
648 for(UINT i=1; i<y.size(); i++){
649 if( y[i] > bestValue ){
654 predictedClassLabel = bestIndex+1;
657 if( classLabel == predictedClassLabel ){
658 classificationPredictions.push_back( bestValue );
659 averageValue += bestValue;
663 averageValue /= double(classificationPredictions.size());
665 for(UINT i=0; i<classificationPredictions.size(); i++){
666 stdDev += SQR(classificationPredictions[i]-averageValue);
668 stdDev = sqrt( stdDev /
double(classificationPredictions.size()-1) );
670 nullRejectionThreshold = averageValue-(stdDev*nullRejectionCoeff);
676 bool MLP::trainOnlineGradientDescentRegression(
const RegressionData &trainingData,
const RegressionData &validationData){
678 const UINT M = trainingData.getNumSamples();
679 const UINT T = trainingData.getNumTargetDimensions();
680 const UINT numValidationSamples = useValidationSet ? validationData.getNumSamples() : M;
683 bool keepTraining =
true;
685 double alpha = learningRate;
686 double beta = momentum;
689 totalSquaredTrainingError = 0;
690 rootMeanSquaredTrainingError = 0;
693 double lastError = 0;
694 double trainingSetTotalSquaredError = 0;
695 double bestError = numeric_limits< double >::max();
696 double bestTSError = numeric_limits< double >::max();
697 double bestRMSError = numeric_limits< double >::max();
699 vector< UINT > indexList(M);
700 vector< vector< double > > tempTrainingErrorLog;
701 TrainingResult result;
702 trainingResults.reserve(M);
705 for(UINT i=0; i<M; i++) indexList[i] = i;
707 for(UINT iter=0; iter<numRandomTrainingIterations; iter++){
711 tempTrainingErrorLog.clear();
714 init(numInputNeurons,numHiddenNeurons,numOutputNeurons,inputLayerActivationFunction,hiddenLayerActivationFunction,outputLayerActivationFunction);
716 if( randomiseTrainingOrder ){
717 for(UINT i=0; i<M; i++){
722 while( keepTraining ){
725 totalSquaredTrainingError = 0;
727 for(UINT i=0; i<M; i++){
729 const VectorDouble &trainingExample = trainingData[ indexList[i] ].getInputVector();
730 const VectorDouble &targetVector = trainingData[ indexList[i] ].getTargetVector();
733 double backPropError =
back_prop(trainingExample,targetVector,alpha,beta);
737 if( isNAN(backPropError) ){
738 keepTraining =
false;
739 errorLog <<
"train(RegressionData trainingData) - NaN found!" << endl;
743 totalSquaredTrainingError += backPropError;
747 keepTraining =
false;
748 errorLog <<
"train(RegressionData trainingData) - NaN found!" << endl;
753 if( useValidationSet ){
754 trainingSetTotalSquaredError = totalSquaredTrainingError;
755 totalSquaredTrainingError = 0;
758 for(UINT i=0; i<numValidationSamples; i++){
759 const VectorDouble &trainingExample = validationData[i].getInputVector();
760 const VectorDouble &targetVector = validationData[i].getTargetVector();
765 for(UINT j=0; j<T; j++){
766 totalSquaredTrainingError += SQR( targetVector[j]-y[j] );
771 rootMeanSquaredTrainingError = sqrt( totalSquaredTrainingError /
double(numValidationSamples) );
774 rootMeanSquaredTrainingError = sqrt( totalSquaredTrainingError /
double(M) );
778 VectorDouble temp(2);
779 temp[0] = trainingSetTotalSquaredError;
780 temp[1] = rootMeanSquaredTrainingError;
781 tempTrainingErrorLog.push_back( temp );
783 error = rootMeanSquaredTrainingError;
786 result.setRegressionResult(iter,totalSquaredTrainingError,rootMeanSquaredTrainingError,
this);
787 trainingResults.push_back( result );
789 delta = fabs( error - lastError );
791 trainingLog <<
"Random Training Iteration: " << iter+1 <<
" Epoch: " << epoch <<
" Error: " << error <<
" Delta: " << delta << endl;
794 if( ++epoch >= maxNumEpochs ){
795 keepTraining =
false;
797 if( delta <= minChange && epoch >= minNumEpochs ){
798 keepTraining =
false;
805 trainingResultsObserverManager.notifyObservers( result );
810 if( lastError < bestError ){
812 bestError = lastError;
813 bestTSError = totalSquaredTrainingError;
814 bestRMSError = rootMeanSquaredTrainingError;
816 trainingErrorLog = tempTrainingErrorLog;
821 trainingLog <<
"Best RMSError: " << bestRMSError <<
" in Random Training Iteration: " << bestIter+1 << endl;
825 errorLog <<
"train(RegressionData trainingData) - NAN Found!" << endl;
831 trainingError = bestRMSError;
837 double MLP::back_prop(
const VectorDouble &trainingExample,
const VectorDouble &targetVector,
const double alpha,
const double beta){
842 feedforward(trainingExample,inputNeuronsOuput,hiddenNeuronsOutput,outputNeuronsOutput);
845 for(UINT i=0; i<numOutputNeurons; i++){
846 deltaO[i] = outputLayer[i].getDerivative( outputNeuronsOutput[i] ) * (targetVector[i]-outputNeuronsOutput[i]);
850 for(UINT i=0; i<numHiddenNeurons; i++){
852 for(UINT j=0; j<numOutputNeurons; j++){
853 sum += outputLayer[j].weights[i] * deltaO[j];
855 deltaH[i] = hiddenLayer[i].getDerivative( hiddenNeuronsOutput[i] ) * sum;
859 for(UINT i=0; i<numHiddenNeurons; i++){
860 for(UINT j=0; j<numInputNeurons; j++){
862 update = alpha * (beta * hiddenLayer[i].previousUpdate[j] + (1.0 - beta) * inputNeuronsOuput[j] * deltaH[i]);
865 hiddenLayer[i].weights[j] += update;
868 hiddenLayer[i].previousUpdate[j] = update;
873 for(UINT i=0; i<numOutputNeurons; i++){
874 for(UINT j=0; j<numHiddenNeurons; j++){
876 update = alpha * (beta * outputLayer[i].previousUpdate[j] + (1.0 - beta) * hiddenNeuronsOutput[j] * deltaO[i]);
879 outputLayer[i].weights[j] += update;
882 outputLayer[i].previousUpdate[j] = update;
888 for(UINT i=0; i<numHiddenNeurons; i++){
890 update = alpha * (beta * hiddenLayer[i].previousBiasUpdate + (1.0 - beta) * deltaH[i]);
893 hiddenLayer[i].bias += update;
896 hiddenLayer[i].previousBiasUpdate = update;
900 for(UINT i=0; i<numOutputNeurons; i++){
902 update = alpha * (beta * outputLayer[i].previousBiasUpdate + (1.0 - beta) * deltaO[i]);
905 outputLayer[i].bias += update;
908 outputLayer[i].previousBiasUpdate = update;
913 for(UINT i=0; i<numOutputNeurons; i++){
914 error += SQR( targetVector[i] - outputNeuronsOutput[i] );
922 if( inputNeuronsOuput.size() != numInputNeurons ) inputNeuronsOuput.resize(numInputNeurons,0);
923 if( hiddenNeuronsOutput.size() != numHiddenNeurons ) hiddenNeuronsOutput.resize(numHiddenNeurons,0);
924 if( outputNeuronsOutput.size() != numOutputNeurons ) outputNeuronsOutput.resize(numOutputNeurons,0);
928 for(UINT i=0; i<numInputNeurons; i++){
929 trainingExample[i] =
scale(trainingExample[i],inputVectorRanges[i].minValue,inputVectorRanges[i].maxValue,0.0,1.0);
934 VectorDouble input(1);
935 for(UINT i=0; i<numInputNeurons; i++){
936 input[0] = trainingExample[i];
937 inputNeuronsOuput[i] = inputLayer[i].fire( input );
941 for(UINT i=0; i<numHiddenNeurons; i++){
942 hiddenNeuronsOutput[i] = hiddenLayer[i].fire( inputNeuronsOuput );
946 for(UINT i=0; i<numOutputNeurons; i++){
947 outputNeuronsOutput[i] = outputLayer[i].fire( hiddenNeuronsOutput );
952 for(
unsigned int i=0; i<numOutputNeurons; i++){
953 outputNeuronsOutput[i] =
scale(outputNeuronsOutput[i],0.0,1.0,targetVectorRanges[i].minValue,targetVectorRanges[i].maxValue);
957 return outputNeuronsOutput;
961 void MLP::feedforward(
const VectorDouble &trainingExample,VectorDouble &inputNeuronsOuput,VectorDouble &hiddenNeuronsOutput,VectorDouble &outputNeuronsOutput){
963 if( inputNeuronsOuput.size() != numInputNeurons ) inputNeuronsOuput.resize(numInputNeurons,0);
964 if( hiddenNeuronsOutput.size() != numHiddenNeurons ) hiddenNeuronsOutput.resize(numHiddenNeurons,0);
965 if( outputNeuronsOutput.size() != numOutputNeurons ) outputNeuronsOutput.resize(numOutputNeurons,0);
968 VectorDouble input(1);
969 for(UINT i=0; i<numInputNeurons; i++){
970 input[0] = trainingExample[i];
971 inputNeuronsOuput[i] = inputLayer[i].fire( input );
975 for(UINT i=0; i<numHiddenNeurons; i++){
976 hiddenNeuronsOutput[i] = hiddenLayer[i].fire( inputNeuronsOuput );
980 for(UINT i=0; i<numOutputNeurons; i++){
981 outputNeuronsOutput[i] = outputLayer[i].fire( hiddenNeuronsOutput );
987 cout<<
"***************** MLP *****************\n";
988 cout<<
"NumInputNeurons: "<<numInputNeurons<<endl;
989 cout<<
"NumHiddenNeurons: "<<numHiddenNeurons<<endl;
990 cout<<
"NumOutputNeurons: "<<numOutputNeurons<<endl;
992 cout<<
"InputWeights:\n";
993 for(UINT i=0; i<numInputNeurons; i++){
994 cout<<
"Neuron: "<<i<<
" Bias: " << inputLayer[i].bias <<
" Weights: ";
995 for(UINT j=0; j<inputLayer[i].weights.size(); j++){
996 cout<<inputLayer[i].weights[j]<<
"\t";
1000 cout<<
"HiddenWeights:\n";
1001 for(UINT i=0; i<numHiddenNeurons; i++){
1002 cout<<
"Neuron: "<<i<<
" Bias: " << hiddenLayer[i].bias <<
" Weights: ";
1003 for(UINT j=0; j<hiddenLayer[i].weights.size(); j++){
1004 cout<<hiddenLayer[i].weights[j]<<
"\t";
1008 cout<<
"OutputWeights:\n";
1009 for(UINT i=0; i<numOutputNeurons; i++){
1010 cout<<
"Neuron: "<<i<<
" Bias: " << outputLayer[i].bias <<
" Weights: ";
1011 for(UINT j=0; j<outputLayer[i].weights.size(); j++){
1012 cout<<outputLayer[i].weights[j]<<
"\t";
1020 for(UINT i=0; i<numInputNeurons; i++){
1021 if( isNAN(inputLayer[i].bias) )
return true;
1022 for(UINT j=0; j<inputLayer[i].weights.size(); j++){
1023 if( isNAN(inputLayer[i].weights[j]) )
return true;
1027 for(UINT i=0; i<numHiddenNeurons; i++){
1028 if( isNAN(hiddenLayer[i].bias) )
return true;
1029 for(UINT j=0; j<hiddenLayer[i].weights.size(); j++){
1030 if( isNAN(hiddenLayer[i].weights[j]) )
return true;
1034 for(UINT i=0; i<numOutputNeurons; i++){
1035 if( isNAN(outputLayer[i].bias) )
return true;
1036 for(UINT j=0; j<outputLayer[i].weights.size(); j++){
1037 if( isNAN(outputLayer[i].weights[j]) )
return true;
1044 bool inline MLP::isNAN(
const double v)
const{
1045 if( v != v )
return true;
1051 if( !file.is_open() ){
1052 errorLog <<
"saveModelToFile(fstream &file) - File is not open!" << endl;
1056 file <<
"GRT_MLP_FILE_V2.0\n";
1060 errorLog <<
"saveModelToFile(fstream &file) - Failed to save Regressifier base settings to file!" << endl;
1064 file <<
"NumInputNeurons: "<<numInputNeurons<<endl;
1065 file <<
"NumHiddenNeurons: "<<numHiddenNeurons<<endl;
1066 file <<
"NumOutputNeurons: "<<numOutputNeurons<<endl;
1070 file <<
"NumRandomTrainingIterations: " << numRandomTrainingIterations << endl;
1071 file <<
"Momentum: " << momentum << endl;
1072 file <<
"Gamma: " << gamma << endl;
1073 file <<
"ClassificationMode: " << classificationModeActive << endl;
1074 file <<
"UseNullRejection: " << useNullRejection << endl;
1075 file <<
"RejectionThreshold: " << nullRejectionThreshold << endl;
1078 file <<
"InputLayer: \n";
1079 for(UINT i=0; i<numInputNeurons; i++){
1080 file <<
"InputNeuron: " << i+1 << endl;
1081 file <<
"NumInputs: " << inputLayer[i].numInputs << endl;
1082 file <<
"Bias: " << inputLayer[i].bias << endl;
1083 file <<
"Gamma: " << inputLayer[i].gamma << endl;
1084 file <<
"Weights: " << endl;
1085 for(UINT j=0; j<inputLayer[i].numInputs; j++){
1086 file << inputLayer[i].weights[j] <<
"\t";
1092 file <<
"HiddenLayer: \n";
1093 for(UINT i=0; i<numHiddenNeurons; i++){
1094 file <<
"HiddenNeuron: " << i+1 << endl;
1095 file <<
"NumInputs: " << hiddenLayer[i].numInputs << endl;
1096 file <<
"Bias: " << hiddenLayer[i].bias << endl;
1097 file <<
"Gamma: " << hiddenLayer[i].gamma << endl;
1098 file <<
"Weights: " << endl;
1099 for(UINT j=0; j<hiddenLayer[i].numInputs; j++){
1100 file << hiddenLayer[i].weights[j] <<
"\t";
1106 file <<
"OutputLayer: \n";
1107 for(UINT i=0; i<numOutputNeurons; i++){
1108 file <<
"OutputNeuron: " << i+1 << endl;
1109 file <<
"NumInputs: " << outputLayer[i].numInputs << endl;
1110 file <<
"Bias: " << outputLayer[i].bias << endl;
1111 file <<
"Gamma: " << outputLayer[i].gamma << endl;
1112 file <<
"Weights: " << endl;
1113 for(UINT j=0; j<outputLayer[i].numInputs; j++){
1114 file << outputLayer[i].weights[j] <<
"\t";
1125 string activationFunction;
1130 if( !file.is_open() ){
1131 errorLog <<
"loadModelFromFile(fstream &file) - File is not open!" << endl;
1141 if( word ==
"GRT_MLP_FILE_V1.0" ){
1142 return loadLegacyModelFromFile( file );
1146 if( word !=
"GRT_MLP_FILE_V2.0" ){
1148 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find file header!" << endl;
1155 errorLog <<
"loadModelFromFile(fstream &file) - Failed to load regressifier base settings from file!" << endl;
1160 if(word !=
"NumInputNeurons:"){
1162 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find NumInputNeurons!" << endl;
1165 file >> numInputNeurons;
1166 numInputDimensions = numInputNeurons;
1169 if(word !=
"NumHiddenNeurons:"){
1171 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find NumHiddenNeurons!" << endl;
1174 file >> numHiddenNeurons;
1177 if(word !=
"NumOutputNeurons:"){
1179 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find NumOutputNeurons!" << endl;
1182 file >> numOutputNeurons;
1185 if(word !=
"InputLayerActivationFunction:"){
1187 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find InputLayerActivationFunction!" << endl;
1190 file >> activationFunction;
1194 if(word !=
"HiddenLayerActivationFunction:"){
1196 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find HiddenLayerActivationFunction!" << endl;
1199 file >> activationFunction;
1203 if(word !=
"OutputLayerActivationFunction:"){
1205 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find OutputLayerActivationFunction!" << endl;
1208 file >> activationFunction;
1212 if(word !=
"NumRandomTrainingIterations:"){
1214 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find NumRandomTrainingIterations!" << endl;
1217 file >> numRandomTrainingIterations;
1220 if(word !=
"Momentum:"){
1222 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find Momentum!" << endl;
1228 if(word !=
"Gamma:"){
1230 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find Gamma!" << endl;
1236 if(word !=
"ClassificationMode:"){
1238 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find ClassificationMode!" << endl;
1241 file >> classificationModeActive;
1244 if(word !=
"UseNullRejection:"){
1246 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find UseNullRejection!" << endl;
1249 file >> useNullRejection;
1252 if(word !=
"RejectionThreshold:"){
1254 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find RejectionThreshold!" << endl;
1257 file >> nullRejectionThreshold;
1259 if( trained ) initialized =
true;
1260 else init(numInputNeurons,numHiddenNeurons,numOutputNeurons);
1265 inputLayer.resize( numInputNeurons );
1266 hiddenLayer.resize( numHiddenNeurons );
1267 outputLayer.resize( numOutputNeurons );
1271 if(word !=
"InputLayer:"){
1273 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find InputLayer!" << endl;
1277 for(UINT i=0; i<numInputNeurons; i++){
1278 UINT tempNeuronID = 0;
1281 if(word !=
"InputNeuron:"){
1283 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find InputNeuron!" << endl;
1286 file >> tempNeuronID;
1288 if( tempNeuronID != i+1 ){
1290 errorLog <<
"loadModelFromFile(fstream &file) - InputNeuron ID does not match!" << endl;
1295 if(word !=
"NumInputs:"){
1297 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find NumInputs!" << endl;
1300 file >> inputLayer[i].numInputs;
1303 inputLayer[i].weights.resize( inputLayer[i].numInputs );
1306 if(word !=
"Bias:"){
1308 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find Bias!" << endl;
1311 file >> inputLayer[i].bias;
1314 if(word !=
"Gamma:"){
1316 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find Gamma!" << endl;
1319 file >> inputLayer[i].gamma;
1322 if(word !=
"Weights:"){
1324 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find Weights!" << endl;
1328 for(UINT j=0; j<inputLayer[i].numInputs; j++){
1329 file >> inputLayer[i].weights[j];
1335 if(word !=
"HiddenLayer:"){
1337 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find HiddenLayer!" << endl;
1341 for(UINT i=0; i<numHiddenNeurons; i++){
1342 UINT tempNeuronID = 0;
1345 if(word !=
"HiddenNeuron:"){
1347 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find HiddenNeuron!" << endl;
1350 file >> tempNeuronID;
1352 if( tempNeuronID != i+1 ){
1354 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find HiddenNeuron ID does not match!" << endl;
1359 if(word !=
"NumInputs:"){
1361 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find NumInputs!" << endl;
1364 file >> hiddenLayer[i].numInputs;
1367 hiddenLayer[i].weights.resize( hiddenLayer[i].numInputs );
1370 if(word !=
"Bias:"){
1372 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find Bias!" << endl;
1375 file >> hiddenLayer[i].bias;
1378 if(word !=
"Gamma:"){
1380 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find Gamma!" << endl;
1383 file >> hiddenLayer[i].gamma;
1386 if(word !=
"Weights:"){
1388 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find Weights!" << endl;
1392 for(
unsigned int j=0; j<hiddenLayer[i].numInputs; j++){
1393 file >> hiddenLayer[i].weights[j];
1399 if(word !=
"OutputLayer:"){
1401 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find OutputLayer!" << endl;
1405 for(UINT i=0; i<numOutputNeurons; i++){
1406 UINT tempNeuronID = 0;
1409 if(word !=
"OutputNeuron:"){
1411 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find OutputNeuron!" << endl;
1414 file >> tempNeuronID;
1416 if( tempNeuronID != i+1 ){
1418 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find OuputNeuron ID does not match!!" << endl;
1423 if(word !=
"NumInputs:"){
1425 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find NumInputs!" << endl;
1428 file >> outputLayer[i].numInputs;
1431 outputLayer[i].weights.resize( outputLayer[i].numInputs );
1434 if(word !=
"Bias:"){
1436 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find Bias!" << endl;
1439 file >> outputLayer[i].bias;
1442 if(word !=
"Gamma:"){
1444 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find Gamma!" << endl;
1447 file >> outputLayer[i].gamma;
1450 if(word !=
"Weights:"){
1452 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find Weights!" << endl;
1456 for(UINT j=0; j<outputLayer[i].numInputs; j++){
1457 file >> outputLayer[i].weights[j];
1467 if( classificationModeActive )
1468 return numOutputNeurons;
1473 return numInputNeurons;
1477 return numHiddenNeurons;
1481 return numOutputNeurons;
1485 return inputLayerActivationFunction;
1489 return hiddenLayerActivationFunction;
1493 return outputLayerActivationFunction;
1497 return numRandomTrainingIterations;
1501 return learningRate;
1513 return trainingError;
1517 return classificationModeActive;
1521 return !classificationModeActive;
1537 return trainingErrorLog;
1541 return useNullRejection;
1545 return nullRejectionCoeff;
1549 return nullRejectionThreshold;
1553 if( trained )
return maxLikelihood;
1554 return DEFAULT_NULL_LIKELIHOOD_VALUE;
1558 if( trained && classificationModeActive )
return classLikelihoods;
1559 return VectorDouble();
1564 if( trained && classificationModeActive )
return regressionData;
1565 return VectorDouble();
1569 if( trained && classificationModeActive )
return predictedClassLabel;
1574 string activationName;
1576 switch(activationFunction){
1577 case(Neuron::LINEAR):
1578 activationName =
"LINEAR";
1580 case(Neuron::SIGMOID):
1581 activationName =
"SIGMOID";
1583 case(Neuron::BIPOLAR_SIGMOID):
1584 activationName =
"BIPOLAR_SIGMOID";
1587 activationName =
"UNKNOWN";
1591 return activationName;
1595 UINT activationFunction = 0;
1597 if(activationName ==
"LINEAR" ){
1598 activationFunction = 0;
1599 return activationFunction;
1601 if(activationName ==
"SIGMOID" ){
1602 activationFunction = 1;
1603 return activationFunction;
1605 if(activationName ==
"BIPOLAR_SIGMOID" ){
1606 activationFunction = 2;
1607 return activationFunction;
1609 return activationFunction;
1613 if( actvationFunction >= Neuron::LINEAR && actvationFunction < Neuron::NUMBER_OF_ACTIVATION_FUNCTIONS )
return true;
1620 warningLog <<
"setInputLayerActivationFunction(const UINT activationFunction) - The activation function is not valid. It should be one of the Neuron ActivationFunctions enums." << endl;
1623 this->inputLayerActivationFunction = activationFunction;
1626 return init(numInputNeurons,numHiddenNeurons,numOutputNeurons);
1636 warningLog <<
"setHiddenLayerActivationFunction(const UINT activationFunction) - The activation function is not valid. It should be one of the Neuron ActivationFunctions enums." << endl;
1639 this->hiddenLayerActivationFunction = activationFunction;
1642 return init(numInputNeurons,numHiddenNeurons,numOutputNeurons);
1652 warningLog <<
"setOutputLayerActivationFunction(const UINT activationFunction) - The activation function is not valid. It should be one of the Neuron ActivationFunctions enums." << endl;
1655 this->outputLayerActivationFunction = activationFunction;
1658 return init(numInputNeurons,numHiddenNeurons,numOutputNeurons);
1669 if( momentum >= 0 && momentum <= 1.0 ){
1670 this->momentum = momentum;
1679 warningLog <<
"setGamma(const double gamma) - Gamma must be greater than zero!" << endl;
1682 this->gamma = gamma;
1685 return init(numInputNeurons,numHiddenNeurons,numOutputNeurons);
1692 if( numRandomTrainingIterations > 0 ){
1693 this->numRandomTrainingIterations = numRandomTrainingIterations;
1700 this->useNullRejection = useNullRejection;
1705 if( nullRejectionCoeff > 0 ){
1706 this->nullRejectionCoeff = nullRejectionCoeff;
1712 bool MLP::loadLegacyModelFromFile( fstream &file ){
1717 if(word !=
"NumInputNeurons:"){
1719 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find NumInputNeurons!" << endl;
1722 file >> numInputNeurons;
1723 numInputDimensions = numInputNeurons;
1726 if(word !=
"NumHiddenNeurons:"){
1728 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find NumHiddenNeurons!" << endl;
1731 file >> numHiddenNeurons;
1734 if(word !=
"NumOutputNeurons:"){
1736 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find NumOutputNeurons!" << endl;
1739 file >> numOutputNeurons;
1742 if(word !=
"InputLayerActivationFunction:"){
1744 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find InputLayerActivationFunction!" << endl;
1751 if(word !=
"HiddenLayerActivationFunction:"){
1753 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find HiddenLayerActivationFunction!" << endl;
1760 if(word !=
"OutputLayerActivationFunction:"){
1762 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find OutputLayerActivationFunction!" << endl;
1769 if(word !=
"MinNumEpochs:"){
1771 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find MinNumEpochs!" << endl;
1774 file >> minNumEpochs;
1777 if(word !=
"MaxNumEpochs:"){
1779 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find MaxNumEpochs!" << endl;
1782 file >> maxNumEpochs;
1785 if(word !=
"NumRandomTrainingIterations:"){
1787 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find NumRandomTrainingIterations!" << endl;
1790 file >> numRandomTrainingIterations;
1793 if(word !=
"ValidationSetSize:"){
1795 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find ValidationSetSize!" << endl;
1798 file >> validationSetSize;
1801 if(word !=
"MinChange:"){
1803 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find MinChange!" << endl;
1809 if(word !=
"TrainingRate:"){
1811 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find TrainingRate!" << endl;
1814 file >> learningRate;
1817 if(word !=
"Momentum:"){
1819 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find Momentum!" << endl;
1825 if(word !=
"Gamma:"){
1827 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find Gamma!" << endl;
1833 if(word !=
"UseValidationSet:"){
1835 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find UseValidationSet!" << endl;
1838 file >> useValidationSet;
1841 if(word !=
"RandomiseTrainingOrder:"){
1843 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find RandomiseTrainingOrder!" << endl;
1846 file >> randomiseTrainingOrder;
1849 if(word !=
"UseScaling:"){
1851 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find UseScaling!" << endl;
1857 if(word !=
"ClassificationMode:"){
1859 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find ClassificationMode!" << endl;
1862 file >> classificationModeActive;
1865 if(word !=
"UseNullRejection:"){
1867 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find UseNullRejection!" << endl;
1870 file >> useNullRejection;
1873 if(word !=
"RejectionThreshold:"){
1875 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find RejectionThreshold!" << endl;
1878 file >> nullRejectionThreshold;
1881 inputLayer.resize( numInputNeurons );
1882 hiddenLayer.resize( numHiddenNeurons );
1883 outputLayer.resize( numOutputNeurons );
1887 if(word !=
"InputLayer:"){
1889 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find InputLayer!" << endl;
1893 for(UINT i=0; i<numInputNeurons; i++){
1894 UINT tempNeuronID = 0;
1897 if(word !=
"InputNeuron:"){
1899 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find InputNeuron!" << endl;
1902 file >> tempNeuronID;
1904 if( tempNeuronID != i+1 ){
1906 errorLog <<
"loadModelFromFile(fstream &file) - InputNeuron ID does not match!" << endl;
1911 if(word !=
"NumInputs:"){
1913 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find NumInputs!" << endl;
1916 file >> inputLayer[i].numInputs;
1919 inputLayer[i].weights.resize( inputLayer[i].numInputs );
1922 if(word !=
"Bias:"){
1924 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find Bias!" << endl;
1927 file >> inputLayer[i].bias;
1930 if(word !=
"Gamma:"){
1932 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find Gamma!" << endl;
1935 file >> inputLayer[i].gamma;
1938 if(word !=
"Weights:"){
1940 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find Weights!" << endl;
1944 for(UINT j=0; j<inputLayer[i].numInputs; j++){
1945 file >> inputLayer[i].weights[j];
1951 if(word !=
"HiddenLayer:"){
1953 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find HiddenLayer!" << endl;
1957 for(UINT i=0; i<numHiddenNeurons; i++){
1958 UINT tempNeuronID = 0;
1961 if(word !=
"HiddenNeuron:"){
1963 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find HiddenNeuron!" << endl;
1966 file >> tempNeuronID;
1968 if( tempNeuronID != i+1 ){
1970 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find HiddenNeuron ID does not match!" << endl;
1975 if(word !=
"NumInputs:"){
1977 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find NumInputs!" << endl;
1980 file >> hiddenLayer[i].numInputs;
1983 hiddenLayer[i].weights.resize( hiddenLayer[i].numInputs );
1986 if(word !=
"Bias:"){
1988 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find Bias!" << endl;
1991 file >> hiddenLayer[i].bias;
1994 if(word !=
"Gamma:"){
1996 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find Gamma!" << endl;
1999 file >> hiddenLayer[i].gamma;
2002 if(word !=
"Weights:"){
2004 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find Weights!" << endl;
2008 for(
unsigned int j=0; j<hiddenLayer[i].numInputs; j++){
2009 file >> hiddenLayer[i].weights[j];
2015 if(word !=
"OutputLayer:"){
2017 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find OutputLayer!" << endl;
2021 for(UINT i=0; i<numOutputNeurons; i++){
2022 UINT tempNeuronID = 0;
2025 if(word !=
"OutputNeuron:"){
2027 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find OutputNeuron!" << endl;
2030 file >> tempNeuronID;
2032 if( tempNeuronID != i+1 ){
2034 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find OuputNeuron ID does not match!!" << endl;
2039 if(word !=
"NumInputs:"){
2041 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find NumInputs!" << endl;
2044 file >> outputLayer[i].numInputs;
2047 outputLayer[i].weights.resize( outputLayer[i].numInputs );
2050 if(word !=
"Bias:"){
2052 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find Bias!" << endl;
2055 file >> outputLayer[i].bias;
2058 if(word !=
"Gamma:"){
2060 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find Gamma!" << endl;
2063 file >> outputLayer[i].gamma;
2066 if(word !=
"Weights:"){
2068 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find Weights!" << endl;
2072 for(UINT j=0; j<outputLayer[i].numInputs; j++){
2073 file >> outputLayer[i].weights[j];
2079 inputVectorRanges.resize( numInputNeurons );
2080 targetVectorRanges.resize( numOutputNeurons );
2084 if(word !=
"InputVectorRanges:"){
2086 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find InputVectorRanges!" << endl;
2089 for(UINT j=0; j<inputVectorRanges.size(); j++){
2090 file >> inputVectorRanges[j].minValue;
2091 file >> inputVectorRanges[j].maxValue;
2095 if(word !=
"OutputVectorRanges:"){
2097 errorLog <<
"loadModelFromFile(fstream &file) - Failed to find OutputVectorRanges!" << endl;
2100 for(UINT j=0; j<targetVectorRanges.size(); j++){
2101 file >> targetVectorRanges[j].minValue;
2102 file >> targetVectorRanges[j].maxValue;
UINT getInputLayerActivationFunction() const
virtual bool saveModelToFile(fstream &file) const
bool setNumRandomTrainingIterations(const UINT numRandomTrainingIterations)
bool copyBaseVariables(const Regressifier *regressifier)
virtual bool train_(ClassificationData &trainingData)
double getMomentum() const
bool getNullRejectionEnabled() const
vector< Neuron > getHiddenLayer() const
double getTrainingRate() const
string activationFunctionToString(const UINT activationFunction) const
virtual bool deepCopyFrom(const Regressifier *regressifier)
double getNullRejectionCoeff() const
bool getRegressionModeActive() const
UINT getNumDimensions() const
UINT getNumClasses() const
virtual bool loadModelFromFile(fstream &file)
bool loadBaseSettingsFromFile(fstream &file)
bool setMomentum(const double momentum)
bool setHiddenLayerActivationFunction(const UINT activationFunction)
static double getMin(const std::vector< double > &x)
UINT getOutputLayerActivationFunction() const
double getMaximumLikelihood() const
UINT getNumClasses() const
vector< MinMax > getInputRanges() const
double getNullRejectionThreshold() const
VectorDouble feedforward(VectorDouble trainingExample)
bool saveBaseSettingsToFile(fstream &file) const
UINT getNumRandomTrainingIterations() const
bool setTrainingRate(const double trainingRate)
virtual bool predict_(VectorDouble &inputVector)
VectorDouble getClassDistances() const
UINT getHiddenLayerActivationFunction() const
bool init(const UINT numInputNeurons, const UINT numHiddenNeurons, const UINT numOutputNeurons)
bool setOutputLayerActivationFunction(const UINT activationFunction)
UINT getNumSamples() const
bool setGamma(const double gamma)
void setSeed(unsigned long long seed=0)
double scale(const double &x, const double &minSource, const double &maxSource, const double &minTarget, const double &maxTarget, const bool constrain=false)
vector< Neuron > getOutputLayer() const
This class implements a Multilayer Perceptron Artificial Neural Network.
virtual bool print() const
void printNetwork() const
RegressionData reformatAsRegressionData() const
string getRegressifierType() const
bool setNullRejection(const bool useNullRejection)
double back_prop(const VectorDouble &trainingExample, const VectorDouble &targetVector, const double alpha, const double beta)
vector< Neuron > getInputLayer() const
UINT getNumInputNeurons() const
int getRandomNumberInt(int minRange, int maxRange)
vector< MinMax > getTargetRanges() const
UINT getPredictedClassLabel() const
UINT getNumHiddenNeurons() const
RegressionData partition(const UINT trainingSizePercentage)
UINT getNumTargetDimensions() const
UINT activationFunctionFromString(const string activationName) const
MLP & operator=(const MLP &rhs)
UINT getNumInputDimensions() const
bool setLearningRate(double learningRate)
bool setInputLayerActivationFunction(const UINT activationFunction)
static double sum(const std::vector< double > &x)
VectorDouble getClassLikelihoods() const
double getTrainingError() const
UINT getNumOutputNeurons() const
bool scale(const double minTarget, const double maxTarget)
vector< VectorDouble > getTrainingLog() const
bool validateActivationFunction(const UINT avactivationFunction) const
bool setNullRejectionCoeff(const double nullRejectionCoeff)
bool getClassificationModeActive() const