SVM.cpp

/*
GRT MIT License
Copyright (c) <2012> <Nicholas Gillian, Media Lab, MIT>

Permission is hereby granted, free of charge, to any person obtaining a copy of this software
and associated documentation files (the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial
portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#define GRT_DLL_EXPORTS
#include "SVM.h"

using namespace LIBSVM;

GRT_BEGIN_NAMESPACE

//Define the string that will be used to identify the object
const std::string SVM::id = "SVM";
std::string SVM::getId() { return SVM::id; }

//Register the SVM module with the Classifier base class
RegisterClassifierModule< SVM > SVM::registerModule( SVM::getId() );

SVM::SVM(KernelType kernelType,SVMType svmType,bool useScaling,bool useNullRejection,bool useAutoGamma,Float gamma,UINT degree,Float coef0,Float nu,Float C,bool useCrossValidation,UINT kFoldValue) : Classifier( SVM::getId() )
{
 
 //Setup the default SVM parameters
 model = NULL;
 param.weight_label = NULL;
 param.weight = NULL;
 prob.l = 0;
 prob.x = NULL;
 prob.y = NULL;
 trained = false;
 problemSet = false;
 param.svm_type = C_SVC;
 param.kernel_type = LINEAR_KERNEL;
 param.degree = 3;
 param.gamma = 0;
 param.coef0 = 0;
 param.nu = 0.5;
 param.cache_size = 100;
 param.C = 1;
 param.eps = 1e-3;
 param.p = 0.1;
 param.shrinking = 1;
 param.probability = 1;
 param.nr_weight = 0;
 param.weight_label = NULL;
 param.weight = NULL;
 this->useScaling = false;
 this->useCrossValidation = false;
 this->useNullRejection = false;
 this->useAutoGamma = true;
 classificationThreshold = 0.5;
 crossValidationResult = 0;
 
 classifierMode = STANDARD_CLASSIFIER_MODE;
 
 init(kernelType,svmType,useScaling,useNullRejection,useAutoGamma,gamma,degree,coef0,nu,C,useCrossValidation,kFoldValue);
}

SVM::SVM(const SVM &rhs) : Classifier( SVM::getId() )
{
 model = NULL;
 param.weight_label = NULL;
 param.weight = NULL;
 prob.l = 0;
 prob.x = NULL;
 prob.y = NULL;
 classifierMode = STANDARD_CLASSIFIER_MODE;
 *this = rhs;
}


SVM::~SVM(){
 clear();
}

SVM& SVM::operator=(const SVM &rhs){
 if( this != &rhs ){
 
 this->clear();
 
 //SVM variables
 this->problemSet = false; //We do not copy the problem set
 this->model = rhs.deepCopyModel();
 this->deepCopyParam( rhs.param, this->param );
 this->numInputDimensions = rhs.numInputDimensions;
 this->kFoldValue = rhs.kFoldValue;
 this->classificationThreshold = rhs.classificationThreshold;
 this->crossValidationResult = rhs.crossValidationResult;
 this->useAutoGamma = rhs.useAutoGamma;
 this->useCrossValidation = rhs.useCrossValidation;
 
 //Classifier variables
 copyBaseVariables( (Classifier*)&rhs );
 }
 return *this;
}

bool SVM::deepCopyFrom(const Classifier *classifier){
 
 if( classifier == NULL ) return false;
 
 if( this->getId() == classifier->getId() ){
 const SVM *ptr = dynamic_cast<const SVM*>(classifier);
 
 this->clear();
 
 //SVM variables
 this->problemSet = false;
 this->model = ptr->deepCopyModel();
 this->deepCopyParam( ptr->param, this->param );
 this->numInputDimensions = ptr->numInputDimensions;
 this->kFoldValue = ptr->kFoldValue;
 this->classificationThreshold = ptr->classificationThreshold;
 this->crossValidationResult = ptr->crossValidationResult;
 this->useAutoGamma = ptr->useAutoGamma;
 this->useCrossValidation = ptr->useCrossValidation;
 
 //Classifier variables
 return copyBaseVariables( classifier );
 }
 
 return false;
}

bool SVM::train_(ClassificationData &trainingData){
 
 //Clear any previous model
 clear();
 
 if( trainingData.getNumSamples() == 0 ){
 errorLog << __GRT_LOG__ << " Training data has zero samples!" << std::endl;
 return false;
 }

 ranges = trainingData.getRanges();
 ClassificationData validationData;
 
 //Scale the training data if needed
 if( useScaling ){
 //Scale the training data between 0 and 1
 trainingData.scale(SVM_MIN_SCALE_RANGE, SVM_MAX_SCALE_RANGE);
 }

 if( useValidationSet ){
 validationData = trainingData.split( 100-validationSetSize );
 }

 //Convert the labelled classification data into the LIBSVM data format
 if( !convertClassificationDataToLIBSVMFormat(trainingData) ){
 errorLog << __GRT_LOG__ << " Failed To Convert Classification Data To LIBSVM Format!" << std::endl;
 return false;
 }
 
 if( useAutoGamma ) param.gamma = 1.0/numInputDimensions;
 
 //Train the model
 bool trainingResult = trainSVM();
 
 if(! trainingResult ){
 errorLog << __GRT_LOG__ << " Failed To Train SVM Model!" << std::endl;
 return false;
 }

 //Flag that the models have been trained
 trained = true;
 converged = true;

 //Compute the final training stats
 trainingSetAccuracy = 0;
 validationSetAccuracy = 0;

 //If scaling was on, then the data will already be scaled, so turn it off temporially so we can test the model accuracy
 bool scalingState = useScaling;
 useScaling = false;
 if( !computeAccuracy( trainingData, trainingSetAccuracy ) ){
 trained = false;
 errorLog << __GRT_LOG__ << " Failed to compute training set accuracy! Failed to fully train model!" << std::endl;
 return false;
 }
 
 if( useValidationSet ){
 if( !computeAccuracy( validationData, validationSetAccuracy ) ){
 trained = false;
 errorLog << __GRT_LOG__ << " Failed to compute validation set accuracy! Failed to fully train model!" << std::endl;
 return false;
 }
 }

 trainingLog << "Training set accuracy: " << trainingSetAccuracy << std::endl;

 if( useValidationSet ){
 trainingLog << "Validation set accuracy: " << validationSetAccuracy << std::endl;
 }

 //Reset the scaling state for future prediction
 useScaling = scalingState;
 
 return trained;
}

bool SVM::predict_(VectorFloat &inputVector){
 
 if( !trained ){
 errorLog << __GRT_LOG__ << " The SVM model has not been trained!" << std::endl;
 return false;
 }
 
 if( inputVector.getSize() != numInputDimensions ){
 errorLog << __GRT_LOG__ << " The size of the input vector (" << inputVector.getSize() << ") does not match the number of features of the model (" << numInputDimensions << ")" << std::endl;
 return false;
 }
 
 if( param.probability == 1 ){
 if( !predictSVM( inputVector, maxLikelihood, classLikelihoods ) ){
 errorLog << __GRT_LOG__ << " Prediction Failed!" << std::endl;
 return false;
 }
 }else{
 if( !predictSVM( inputVector ) ){
 errorLog << __GRT_LOG__ << " Prediction Failed!" << std::endl;
 return false;
 }
 }
 
 return true;
}

bool SVM::init(KernelType kernelType,SVMType svmType,bool useScaling,bool useNullRejection,bool useAutoGamma,Float gamma,UINT degree,Float coef0,Float nu,Float C,bool useCrossValidation,UINT kFoldValue){
 
 //Clear any previous models or problems
 clear();
 
 //Validate the kernerlType
 if( !validateKernelType(kernelType) ){
 errorLog << __GRT_LOG__ << " Unknown kernelType!\n";
 return false;
 }
 
 if( !validateSVMType(svmType) ){
 errorLog << __GRT_LOG__ << " Unknown kernelType!\n";
 return false;
 }
 
 param.svm_type = (int)svmType;
 param.kernel_type = (int)kernelType;
 param.degree = (int)degree;
 param.gamma = gamma;
 param.coef0 = coef0;
 param.nu = nu;
 param.cache_size = 100;
 param.C = C;
 param.eps = 1e-3;
 param.p = 0.1;
 param.shrinking = 1;
 param.probability = 1;
 param.nr_weight = 0;
 param.weight_label = NULL;
 param.weight = NULL;
 this->useScaling = useScaling;
 this->useCrossValidation = useCrossValidation;
 this->useNullRejection = useNullRejection;
 this->useAutoGamma = useAutoGamma;
 classificationThreshold = 0.5;
 crossValidationResult = 0;
 
 return true;
}

void SVM::deleteProblemSet(){
 if( problemSet ){
 for(int i=0; i<prob.l; i++){
 delete[] prob.x[i];
 prob.x[i] = NULL;
 }
 delete[] prob.x;
 delete[] prob.y;
 prob.l = 0;
 prob.x = NULL;
 prob.y = NULL;
 problemSet = false;
 }
}

void SVM::initDefaultSVMSettings(){
 
 //Clear any previous models, parameters or probelms
 clear();
 
 //Setup the SVM parameters
 param.svm_type = C_SVC;
 param.kernel_type = LINEAR_KERNEL;
 param.degree = 3;
 param.gamma = 0;
 param.coef0 = 0;
 param.nu = 0.5;
 param.cache_size = 100;
 param.C = 1;
 param.eps = 1e-3;
 param.p = 0.1;
 param.shrinking = 1;
 param.probability = 1;
 param.nr_weight = 0;
 param.weight_label = NULL;
 param.weight = NULL;
 useCrossValidation = false;
 kFoldValue = 10;
 useAutoGamma = true;
}

bool SVM::validateProblemAndParameters(){
 //Check the parameters match the problem
 const char *errorMsg = svm_check_parameter(&prob,&param);
 
 if( errorMsg ){
 errorLog << __GRT_LOG__ << " Parameters do not match problem! error: " << errorMsg << std::endl;
 return false;
 }
 
 return true;
}

bool SVM::trainSVM(){
 
 crossValidationResult = 0;
 
 //Erase any previous models
 if( trained ){
 svm_free_and_destroy_model(&model);
 trained = false;
 }
 
 //Check to make sure the problem has been set
 if( !problemSet ){
 errorLog << __GRT_LOG__ << " Problem not set!" << std::endl;
 return false;
 }
 
 //Verify the problem and the parameters
 if( !validateProblemAndParameters() ) return false;
 
 if( useCrossValidation ){
 int i;
 Float total_correct = 0;
 Float total_error = 0;
 Float sumv = 0, sumy = 0, sumvv = 0, sumyy = 0, sumvy = 0;
 Float *target = new Float[prob.l];
 
 svm_cross_validation(&prob,&param,kFoldValue,target);
 if( param.svm_type == EPSILON_SVR || param.svm_type == NU_SVR )
 {
 for(i=0;i<prob.l;i++)
 {
 Float y = prob.y[i];
 Float v = target[i];
 total_error += (v-y)*(v-y);
 sumv += v;
 sumy += y;
 sumvv += v*v;
 sumyy += y*y;
 sumvy += v*y;
 }
 crossValidationResult = total_error/prob.l;
 }
 else
 {
 for(i=0;i<prob.l;i++){
 if(target[i] == prob.y[i]){
 ++total_correct;
 }
 }
 crossValidationResult = total_correct/prob.l*100.0;
 }
 delete[] target;
 }
 
 //Train the SVM - if we are running cross validation then the CV will be run first followed by a full train
 model = svm_train(&prob,&param);
 
 if( model == NULL ){
 errorLog << __GRT_LOG__ << " Failed to train SVM Model!" << std::endl;
 return false;
 }
 
 if( model != NULL ){
 trained = true;
 numClasses = getNumClasses();
 classLabels.resize( getNumClasses() );
 for(UINT k=0; k<getNumClasses(); k++){
 classLabels[k] = model->label[k];
 }
 classLikelihoods.resize(numClasses,DEFAULT_NULL_LIKELIHOOD_VALUE);
 classDistances.resize(numClasses,DEFAULT_NULL_DISTANCE_VALUE);
 }
 
 return trained;
}

bool SVM::predictSVM(VectorFloat &inputVector){
 
 if( !trained || inputVector.size() != numInputDimensions ) return false;
 
 svm_node *x = NULL;
 
 //Copy the input data into the SVM format
 x = new svm_node[numInputDimensions+1];
 for(UINT j=0; j<numInputDimensions; j++){
 x[j].index = (int)j+1;
 x[j].value = inputVector[j];
 }
 //The last value in the input vector must be set to -1
 x[numInputDimensions].index = -1;
 x[numInputDimensions].value = 0;
 
 //Scale the input data if required
 if( useScaling ){
 for(UINT i=0; i<numInputDimensions; i++)
 x[i].value = grt_scale(x[i].value,ranges[i].minValue,ranges[i].maxValue,SVM_MIN_SCALE_RANGE,SVM_MAX_SCALE_RANGE);
 }
 
 //Perform the SVM prediction
 Float predict_label = svm_predict(model,x);
 
 //We can't do null rejection without the probabilities, so just set the predicted class
 predictedClassLabel = (UINT)predict_label;
 
 //Clean up the memory
 delete[] x;
 
 return true;
}

bool SVM::predictSVM(VectorFloat &inputVector,Float &maxProbability, VectorFloat &probabilites){
 
 if( !trained || param.probability == 0 || inputVector.size() != numInputDimensions ) return false;
 
 Float *prob_estimates = NULL;
 svm_node *x = NULL;
 
 //Setup the memory for the probability estimates
 prob_estimates = new Float[ model->nr_class ];
 
 //Copy the input data into the SVM format
 x = new svm_node[numInputDimensions+1];
 for(UINT j=0; j<numInputDimensions; j++){
 x[j].index = (int)j+1;
 x[j].value = inputVector[j];
 }
 //The last value in the input vector must be set to -1
 x[numInputDimensions].index = -1;
 x[numInputDimensions].value = 0;
 
 //Scale the input data if required
 if( useScaling ){
 for(UINT j=0; j<numInputDimensions; j++)
 x[j].value = grt_scale(x[j].value,ranges[j].minValue,ranges[j].maxValue,SVM_MIN_SCALE_RANGE,SVM_MAX_SCALE_RANGE);
 }
 
 //Perform the SVM prediction
 Float predict_label = svm_predict_probability(model,x,prob_estimates);
 
 predictedClassLabel = 0;
 maxProbability = 0;
 probabilites.resize(model->nr_class);
 for(int k=0; k<model->nr_class; k++){
 if( maxProbability < prob_estimates[k] ){
 maxProbability = prob_estimates[k];
 predictedClassLabel = k+1;
 maxLikelihood = maxProbability;
 }
 probabilites[k] = prob_estimates[k];
 }
 
 if( !useNullRejection ) predictedClassLabel = (UINT)predict_label;
 else{
 if( maxProbability >= classificationThreshold ){
 predictedClassLabel = (UINT)predict_label;
 }else predictedClassLabel = GRT_DEFAULT_NULL_CLASS_LABEL;
 }
 
 //Clean up the memory
 delete[] prob_estimates;
 delete[] x;
 
 return true;
}

bool SVM::convertClassificationDataToLIBSVMFormat(ClassificationData &trainingData){
 
 //clear any previous problems
 deleteProblemSet();
 
 const UINT numTrainingExamples = trainingData.getNumSamples();
 numInputDimensions = trainingData.getNumDimensions();
 numOutputDimensions = trainingData.getNumClasses();
 
 //Init the memory
 prob.l = numTrainingExamples;
 prob.x = new svm_node*[numTrainingExamples];
 prob.y = new Float[numTrainingExamples];
 problemSet = true;
 
 for(UINT i=0; i<numTrainingExamples; i++){
 //Set the class ID
 prob.y[i] = trainingData[i].getClassLabel();
 
 //Assign the memory for this training example, note that a dummy node is needed at the end of the vector
 prob.x[i] = new svm_node[numInputDimensions+1];
 for(UINT j=0; j<numInputDimensions; j++){
 prob.x[i][j].index = j+1;
 prob.x[i][j].value = trainingData[i].getSample()[j];
 }
 prob.x[i][numInputDimensions].index = -1; //Assign the final node value
 prob.x[i][numInputDimensions].value = 0;
 }
 
 return true;
}

bool SVM::save( std::fstream &file ) const{
 
 if( !file.is_open() ){
 return false;
 }
 
 file << "SVM_MODEL_FILE_V2.0\n";
 
 //Write the classifier settings to the file
 if( !Classifier::saveBaseSettingsToFile(file) ){
 errorLog << __GRT_LOG__ << " Failed to save classifier base settings to file!" << std::endl;
 return false;
 }
 
 const svm_parameter& param = trained ? model->param : this->param;
 
 file << "ModelType: ";
 switch( param.svm_type ){
 case(C_SVC):
 file << "C_SVC";
 break;
 case(NU_SVC):
 file << "NU_SVC";
 break;
 case(ONE_CLASS):
 file << "ONE_CLASS";
 break;
 case(EPSILON_SVR):
 file << "EPSILON_SVR";
 break;
 case(NU_SVR):
 file << "NU_SVR";
 break;
 default:
 errorLog << __GRT_LOG__ << " Invalid model type: " << param.svm_type << std::endl;
 return false;
 break;
 }
 file << std::endl;
 
 file << "KernelType: ";
 switch(param.kernel_type){
 case(LINEAR):
 file << "LINEAR";
 break;
 case(POLY):
 file << "POLYNOMIAL";
 break;
 case(RBF):
 file << "RBF";
 break;
 case(SIGMOID):
 file << "SIGMOID";
 break;
 case(PRECOMPUTED):
 file << "PRECOMPUTED";
 break;
 default:
 errorLog << __GRT_LOG__ << " Invalid kernel type: " << param.kernel_type << std::endl;
 return false;
 break;
 }
 file << std::endl;
 file << "Degree: " << param.degree << std::endl;
 file << "Gamma: " << param.gamma << std::endl;
 file << "Coef0: " << param.coef0 << std::endl;
 file << "NumberOfFeatures: " << numInputDimensions << std::endl;
 file << "UseShrinking: " << param.shrinking << std::endl;
 file << "UseProbability: " << param.probability << std::endl;
 
 if( trained ){
 UINT numClasses = (UINT)model->nr_class;
 UINT numSV = (UINT)model->l;
 file << "NumberOfSupportVectors: " << numSV << std::endl;
 
 file << "RHO: \n";
 for(UINT i=0;i<numClasses*(numClasses-1)/2;i++) file << model->rho[i] << "\t";
 file << "\n";
 
 if(model->label){
 file << "Label: \n";
 for(UINT i=0;i<numClasses;i++) file << model->label[i] << "\t";
 file << "\n";
 }
 
 if(model->probA){ // regression has probA only
 file << "ProbA: \n";
 for(UINT i=0;i<numClasses*(numClasses-1)/2;i++) file << model->probA[i] << "\t";
 file << "\n";
 }
 
 if(model->probB){
 file << "ProbB: \n";
 for(UINT i=0;i<numClasses*(numClasses-1)/2;i++) file << model->probB[i] << "\t";
 file << "\n";
 }
 
 if(model->nSV){
 file << "NumSupportVectorsPerClass: \n";
 for(UINT i=0;i<numClasses;i++) file << model->nSV[i] << "\t";
 file << "\n";
 }
 
 file << "SupportVectors: \n";
 
 const Float * const *sv_coef = model->sv_coef;
 const svm_node * const *SV = model->SV;
 
 for(UINT i=0;i<numSV;i++){
 for(UINT j=0;j<numClasses-1;j++)
 file << sv_coef[j][i] << "\t";
 
 const svm_node *p = SV[i];
 
 if(param.kernel_type == PRECOMPUTED) file << (int) p->value << "\t";
 else{
 while(p->index != -1){
 file << p->index << "\t" << p->value << "\t";
 p++;
 }
 file << "\n";
 }
 }
 }
 
 return true;
}

bool SVM::load( std::fstream &file ){
 
 std::string word;
 UINT numSV = 0;
 UINT halfNumClasses = 0;
 
 //Clear any previous models, parameters or problems
 clear();
 
 if( !file.is_open() ){
 errorLog << __GRT_LOG__ << " The file is not open!" << std::endl;
 return false;
 }
 
 //Read the file header
 file >> word;
 
 //Check to see if we should load a legacy file
 if( word == "SVM_MODEL_FILE_V1.0" ){
 return loadLegacyModelFromFile( file );
 }
 
 //Check to make sure this is a file with the correct File Format
 if( word != "SVM_MODEL_FILE_V2.0" ){
 errorLog << __GRT_LOG__ << " Invalid file format!" << std::endl;
 clear();
 return false;
 }
 
 //Load the base settings from the file
 if( !Classifier::loadBaseSettingsFromFile(file) ){
 errorLog << __GRT_LOG__ << " Failed to load base settings from file!" << std::endl;
 return false;
 }
 
 //Init the memory for the model
 model = new svm_model;
 model->nr_class = 0;
 model->l = 0;
 model->SV = NULL;
 model->sv_coef = NULL;
 model->rho = NULL;
 model->probA = NULL;
 model->probB = NULL;
 model->label = NULL;
 model->nSV = NULL;
 model->label = NULL;
 model->nSV = NULL;
 model->free_sv = 0; //This will be set to 1 if everything is loaded OK
 
 //Init the memory for the parameters
 model->param.svm_type = 0;
 model->param.kernel_type = 0;
 model->param.degree = 0;
 model->param.gamma = 0;
 model->param.coef0 = 0;
 model->param.cache_size = 0;
 model->param.eps = 0;
 model->param.C = 0;
 model->param.nr_weight = 0;
 model->param.weight_label = NULL;
 model->param.weight = NULL;
 model->param.nu = 0;
 model->param.p = 0;
 model->param.shrinking = 0;
 model->param.probability = 1;
 
 //Load the model type
 file >> word;
 if(word != "ModelType:"){
 errorLog << __GRT_LOG__ << " Failed to find ModelType header!" << std::endl;
 clear();
 return false;
 }
 file >> word;
 if( word == "C_SVC" ){
 model->param.svm_type = C_SVC;
 }else{
 if( word == "NU_SVC" ){
 model->param.svm_type = NU_SVC;
 }else{
 if( word == "ONE_CLASS" ){
 model->param.svm_type = ONE_CLASS;
 }else{
 if( word == "EPSILON_SVR" ){
 model->param.svm_type = EPSILON_SVR;
 }else{
 if( word == "NU_SVR" ){
 model->param.svm_type = NU_SVR;
 }else{
 errorLog << __GRT_LOG__ << " Failed to find SVM type!" << std::endl;
 clear();
 return false;
 }
 }
 }
 }
 }
 
 //Load the model type
 file >> word;
 if(word != "KernelType:"){
 errorLog << __GRT_LOG__ << " Failed to find kernel type!" << std::endl;
 clear();
 return false;
 }
 file >> word;
 if( word == "LINEAR" ){
 model->param.kernel_type = LINEAR;
 }else{
 if( word == "POLYNOMIAL" ){
 model->param.kernel_type = POLY;
 }else{
 if( word == "RBF" ){
 model->param.kernel_type = RBF;
 }else{
 if( word == "SIGMOID" ){
 model->param.kernel_type = SIGMOID;
 }else{
 if( word == "PRECOMPUTED" ){
 model->param.kernel_type = PRECOMPUTED;
 }else{
 errorLog << __GRT_LOG__ << " Failed to find kernel type!" << std::endl;
 clear();
 return false;
 }
 }
 }
 }
 }
 
 //Load the degree
 file >> word;
 if(word != "Degree:"){
 errorLog << __GRT_LOG__ << " Failed to find Degree header!" << std::endl;
 clear();
 return false;
 }
 file >> model->param.degree;
 
 //Load the gamma
 file >> word;
 if(word != "Gamma:"){
 errorLog << __GRT_LOG__ << " Failed to find Gamma header!" << std::endl;
 clear();
 return false;
 }
 file >> model->param.gamma;
 
 //Load the Coef0
 file >> word;
 if(word != "Coef0:"){
 errorLog << __GRT_LOG__ << " Failed to find Coef0 header!" << std::endl;
 clear();
 return false;
 }
 file >> model->param.coef0;
 
 //Load the NumberOfFeatures
 file >> word;
 if(word != "NumberOfFeatures:"){
 errorLog << __GRT_LOG__ << " Failed to find NumberOfFeatures header!" << std::endl;
 clear();
 return false;
 }
 file >> numInputDimensions;
 
 //Load the UseShrinking
 file >> word;
 if(word != "UseShrinking:"){
 errorLog << __GRT_LOG__ << " Failed to find UseShrinking header!" << std::endl;
 clear();
 return false;
 }
 file >> model->param.shrinking;
 
 //Load the UseProbability
 file >> word;
 if(word != "UseProbability:"){
 errorLog << __GRT_LOG__ << " Failed to find UseProbability header!" << std::endl;
 clear();
 return false;
 }
 file >> model->param.probability;
 
 if( trained ){
 //Load the NumberOfSupportVectors
 file >> word;
 if(word != "NumberOfSupportVectors:"){
 errorLog << __GRT_LOG__ << " Failed to find NumberOfSupportVectors header!" << std::endl;
 clear();
 return false;
 }
 file >> numSV;
 
 //Setup the values
 halfNumClasses = numClasses*(numClasses-1)/2;
 model->nr_class = numClasses;
 model->l = numSV;
 
 //Load the RHO
 file >> word;
 if(word != "RHO:"){
 errorLog << __GRT_LOG__ << " Failed to find RHO header!" << std::endl;
 clear();
 return false;
 }
 model->rho = new Float[ halfNumClasses ];
 for(UINT i=0;i<numClasses*(numClasses-1)/2;i++) file >> model->rho[i];
 
 //See if we can load the Labels
 file >> word;
 if(word != "Label:"){
 model->label = NULL;
 }else{
 model->label = new int[ numClasses ];
 for(UINT i=0;i<numClasses;i++) file >> model->label[i];
 //We only need to read a new line if we found the label!
 file >> word;
 }
 
 //See if we can load the ProbA
 //We don't need to read another line here
 if(word != "ProbA:"){
 model->probA = NULL;
 }else{
 model->probA = new Float[ halfNumClasses ];
 for(UINT i=0;i<numClasses*(numClasses-1)/2;i++) file >> model->probA[i];
 //We only need to read a new line if we found the label!
 file >> word;
 }
 
 //See if we can load the ProbB
 //We don't need to read another line here
 if(word != "ProbB:"){
 model->probB = NULL;
 }else{
 model->probB = new Float[ halfNumClasses ];
 for(UINT i=0;i<numClasses*(numClasses-1)/2;i++) file >> model->probB[i];
 //We only need to read a new line if we found the label!
 file >> word;
 }
 
 //See if we can load the NumSupportVectorsPerClass
 //We don't need to read another line here
 if( word == "NumSupportVectorsPerClass:" ){
 model->nSV = new int[ numClasses ];
 for(UINT i=0; i<numClasses; i++) file >> model->nSV[i];
 //We only need to read a new line if we found the label!
 file >> word;
 }else{
 model->nSV = NULL;
 }
 
 //Load the SupportVectors
 //We don't need to read another line here
 if(word != "SupportVectors:"){
 errorLog << __GRT_LOG__ << " Failed to find SupportVectors header!" << std::endl;
 clear();
 return false;
 }
 
 //Setup the memory
 model->sv_coef = new Float*[numClasses-1];
 for(UINT j=0;j<numClasses-1;j++) model->sv_coef[j] = new Float[numSV];
 model->SV = new svm_node*[numSV];
 
 for(UINT i=0; i<numSV; i++){
 for(UINT j=0; j<numClasses-1; j++){
 file >> model->sv_coef[j][i];
 }
 
 model->SV[i] = new svm_node[numInputDimensions+1];
 
 if(model->param.kernel_type == PRECOMPUTED) file >> model->SV[i][0].value;
 else{
 for(UINT j=0; j<numInputDimensions; j++){
 file >> model->SV[i][j].index;
 file >> model->SV[i][j].value;
 }
 model->SV[i][numInputDimensions].index = -1; //Assign the final node value
 model->SV[i][numInputDimensions].value = 0;
 }
 }
 
 //Set the class labels
 this->numClasses = getNumClasses();
 classLabels.resize(getNumClasses());
 for(UINT k=0; k<getNumClasses(); k++){
 classLabels[k] = model->label[k];
 }
 
 //The SV have now been loaded so flag that they should be deleted
 model->free_sv = 1;
 
 //Resize the prediction results to make sure it is setup for realtime prediction
 maxLikelihood = DEFAULT_NULL_LIKELIHOOD_VALUE;
 bestDistance = DEFAULT_NULL_DISTANCE_VALUE;
 classLikelihoods.resize(numClasses,DEFAULT_NULL_LIKELIHOOD_VALUE);
 classDistances.resize(numClasses,DEFAULT_NULL_DISTANCE_VALUE);
 }
 
 return true;
}

bool SVM::clear(){
 
 //Clear the base class
 Classifier::clear();
 
 crossValidationResult = 0;
 trained = false;
 svm_free_and_destroy_model(&model);
 svm_destroy_param(&param);
 deleteProblemSet();
 
 return true;
}

bool SVM::getIsCrossValidationTrainingEnabled() const{
 return useCrossValidation;
}

bool SVM::getIsAutoGammaEnabled() const{
 return useAutoGamma;
}

std::string SVM::getSVMType() const{
 
 const struct svm_parameter *paramPtr = NULL;
 std::string modelName = "UNKNOWN";
 if( trained ){
 paramPtr = &model->param;
 }else paramPtr = &param;
 
 switch(paramPtr->svm_type){
 case(C_SVC):
 modelName = "C_SVC";
 break;
 case(NU_SVC):
 modelName = "NU_SVC";
 break;
 case(ONE_CLASS):
 modelName = "ONE_CLASS";
 break;
 case(EPSILON_SVR):
 modelName = "EPSILON_SVR";
 break;
 case(NU_SVR):
 modelName = "NU_SVR";
 break;
 default:
 break;
 }
 
 return modelName;
}

std::string SVM::getKernelType() const{
 const struct svm_parameter *paramPtr = NULL;
 std::string modelName = "UNKNOWN";
 if( trained ){
 paramPtr = &model->param;
 }else paramPtr = &param;
 
 switch(paramPtr->kernel_type){
 case(LINEAR_KERNEL):
 modelName = "LINEAR_KERNEL";
 break;
 case(POLY_KERNEL):
 modelName = "POLY_KERNEL";
 break;
 case(RBF_KERNEL):
 modelName = "RBF_KERNEL";
 break;
 case(SIGMOID_KERNEL):
 modelName = "SIGMOID_KERNEL";
 break;
 case(PRECOMPUTED_KERNEL):
 modelName = "PRECOMPUTED_KERNEL";
 break;
 default:
 break;
 }
 return modelName;
}

UINT SVM::getNumClasses() const{
 if( !trained ) return 0;
 return (UINT) model->nr_class;
}

UINT SVM::getDegree() const{
 if( trained ){
 return (UINT)model->param.degree;
 }
 return (UINT)param.gamma;
}

Float SVM::getGamma() const{
 if( trained ){
 return model->param.gamma;
 }
 return param.gamma;
}

Float SVM::getNu() const{
 if( trained ){
 return model->param.nu;
 }
 return param.gamma;
}

Float SVM::getCoef0() const{
 if( trained ){
 return model->param.coef0;
 }
 return param.gamma;
}

Float SVM::getC() const{
 if( trained ){
 return model->param.C;
 }
 return param.gamma;
}

Float SVM::getCrossValidationResult() const{ return crossValidationResult; }

const struct LIBSVM::svm_model* SVM::getLIBSVMModel() const { return model; }

bool SVM::setSVMType(const SVMType svmType){
 if( validateSVMType(svmType) ){
 param.svm_type = (int)svmType;
 return true;
 }
 return false;
}

bool SVM::setKernelType(const KernelType kernelType){

 if( validateKernelType(kernelType) ){
 param.kernel_type = (int)kernelType;
 return true;
 }
 warningLog << __GRT_LOG__ << " Failed to set kernel type, unknown kernelType!" << std::endl;
 return false;
}

bool SVM::setGamma(const Float gamma){
 if( !useAutoGamma ){
 this->param.gamma = gamma;
 return true;
 }
 warningLog << __GRT_LOG__ << " Failed to set gamma, useAutoGamma is enabled, setUseAutoGamma to false first!" << std::endl;
 return false;
}

bool SVM::setDegree(const UINT degree){
 this->param.degree = (int)degree;
 return true;
}

bool SVM::setNu(const Float nu){
 this->param.nu = nu;
 return true;
}

bool SVM::setCoef0(const Float coef0){
 this->param.coef0 = coef0;
 return true;
}

bool SVM::setC(const Float C){
 this->param.C = C;
 return true;
}

bool SVM::setKFoldCrossValidationValue(const UINT kFoldValue){
 if( kFoldValue > 0 ){
 this->kFoldValue = kFoldValue;
 return true;
 }
 warningLog << __GRT_LOG__ << " Failed to set kFoldValue, the kFoldValue must be greater than 0!" << std::endl;
 return false;
}

bool SVM::enableAutoGamma(const bool useAutoGamma){
 this->useAutoGamma = useAutoGamma;
 return true;
}

bool SVM::enableCrossValidationTraining(const bool useCrossValidation){
 this->useCrossValidation = useCrossValidation;
 return true;
}
 
bool SVM::validateSVMType(const SVMType svmType){
 if( svmType == C_SVC ){
 return true;
 }
 if( svmType == NU_SVC ){
 return true;
 }
 if( svmType == ONE_CLASS ){
 return true;
 }
 if( svmType == EPSILON_SVR ){
 return true;
 }
 if( svmType == NU_SVR ){
 return true;
 }
 return false;
}

bool SVM::validateKernelType(const KernelType kernelType){
 if( kernelType == LINEAR_KERNEL ){
 return true;
 }
 if( kernelType == POLY_KERNEL ){
 return true;
 }
 if( kernelType == RBF_KERNEL ){
 return true;
 }
 if( kernelType == SIGMOID_KERNEL ){
 return true;
 }
 if( kernelType == PRECOMPUTED_KERNEL ){
 return true;
 }
 return false;
}

struct svm_model* SVM::deepCopyModel() const{
 
 if( model == NULL ) return NULL;
 
 UINT halfNumClasses = 0;
 
 //Init the memory for the model
 struct svm_model *m = new svm_model;
 m->nr_class = 0;
 m->l = 0;
 m->SV = NULL;
 m->sv_coef = NULL;
 m->rho = NULL;
 m->probA = NULL;
 m->probB = NULL;
 m->label = NULL;
 m->nSV = NULL;
 m->label = NULL;
 m->nSV = NULL;
 m->free_sv = 0; //This will be set to 1 if everything is loaded OK
 
 //Init the memory for the parameters
 m->param.svm_type = 0;
 m->param.kernel_type = 0;
 m->param.degree = 0;
 m->param.gamma = 0;
 m->param.coef0 = 0;
 m->param.cache_size = 0;
 m->param.eps = 0;
 m->param.C = 0;
 m->param.nr_weight = 0;
 m->param.weight_label = NULL;
 m->param.weight = NULL;
 m->param.nu = 0;
 m->param.p = 0;
 m->param.shrinking = 0;
 m->param.probability = 1;
 
 //Copy the parameters
 m->param.svm_type = model->param.svm_type;
 m->param.kernel_type = model->param.kernel_type ;
 m->param.degree = model->param.degree;
 m->param.gamma = model->param.gamma;
 m->param.coef0 = model->param.coef0;
 m->nr_class = model->nr_class;
 m->l = model->l;
 m->param.shrinking = model->param.shrinking;
 m->param.probability = model->param.probability;
 
 //Setup the values
 halfNumClasses = model->nr_class*(model->nr_class-1)/2;
 
 m->rho = new Float[ halfNumClasses ];
 for(int i=0;i <model->nr_class*(model->nr_class-1)/2; i++) m->rho[i] = model->rho[i];
 
 if( model->label != NULL ){
 m->label = new int[ model->nr_class ];
 for(int i=0;i<model->nr_class;i++) m->label[i] = model->label[i];
 }
 
 if( model->probA != NULL ){
 m->probA = new Float[ halfNumClasses ];
 for(UINT i=0;i<halfNumClasses; i++) m->probA[i] = model->probA[i];
 }
 
 if( model->probB != NULL ){
 m->probB = new Float[ halfNumClasses ];
 for(UINT i=0; i<halfNumClasses; i++) m->probB[i] = model->probB[i];
 }
 
 if( model->nSV != NULL ){
 m->nSV = new int[ model->nr_class ];
 for(int i=0; i<model->nr_class; i++) m->nSV[i] = model->nSV[i];
 }
 
 //Setup the memory
 m->sv_coef = new Float*[numClasses-1];
 for(UINT j=0;j<numClasses-1;j++) m->sv_coef[j] = new Float[model->l];
 m->SV = new svm_node*[model->l];
 
 for(int i=0; i<model->l; i++){
 for(int j=0; j<model->nr_class-1; j++){
 m->sv_coef[j][i] = model->sv_coef[j][i];
 }
 
 m->SV[i] = new svm_node[numInputDimensions+1];
 
 if(model->param.kernel_type == PRECOMPUTED) m->SV[i][0].value = model->SV[i][0].value;
 else{
 for(UINT j=0; j<numInputDimensions; j++){
 m->SV[i][j].index = model->SV[i][j].index;
 m->SV[i][j].value = model->SV[i][j].value;
 }
 m->SV[i][numInputDimensions].index = -1; //Assign the final node value
 m->SV[i][numInputDimensions].value = 0;
 }
 }
 
 //The SV have now been loaded so flag that they should be deleted
 m->free_sv = 1;
 
 return m;
}

bool SVM::deepCopyProblem( const struct svm_problem &source, struct svm_problem &target, const unsigned int numInputDimensions ) const{
 
 //Cleanup the target memory
 if( target.y != NULL ){
 delete[] target.y;
 target.y = NULL;
 }
 if( target.x != NULL ){
 for(int i=0; i<target.l; i++){
 delete[] target.x[i];
 target.x[i] = NULL;
 }
 }
 
 //Deep copy the source to the target
 target.l = source.l;
 
 if( source.x != NULL ){
 target.x = new svm_node*[ target.l ];
 for(int i=0; i<target.l; i++){
 target.x[i] = new svm_node[ numInputDimensions+1 ];
 for(unsigned int j=0; j<numInputDimensions+1; j++){
 target.x[i][j] = source.x[i][j];
 }
 }
 }
 
 if( source.y != NULL ){
 target.y = new Float[ target.l ];
 for(int i=0; i<target.l; i++){
 target.y[i] = source.y[i];
 }
 }
 
 return true;
}

bool SVM::deepCopyParam( const svm_parameter &source_param, svm_parameter &target_param ) const{
 
 //Cleanup any dynamic memory in the target
 if( target_param.weight_label != NULL ){
 delete[] target_param.weight_label;
 target_param.weight_label = NULL;
 }
 if( target_param.weight != NULL ){
 delete[] target_param.weight;
 target_param.weight = NULL;
 }
 
 //Copy the non dynamic variables
 target_param.svm_type = source_param.svm_type;
 target_param.kernel_type = source_param.kernel_type;
 target_param.degree = source_param.degree;
 target_param.gamma = source_param.gamma;
 target_param.coef0 = source_param.coef0;
 target_param.cache_size = source_param.cache_size;
 target_param.eps = source_param.eps;
 target_param.C = source_param.C;
 target_param.nr_weight = source_param.nr_weight;
 target_param.nu = source_param.nu;
 target_param.p = source_param.p;
 target_param.shrinking = source_param.shrinking;
 target_param.probability = source_param.probability;
 
 //Copy any dynamic memory
 if( source_param.weight_label != NULL ){
 
 }
 if( source_param.weight != NULL ){
 
 }
 
 return true;
}

bool SVM::loadLegacyModelFromFile( std::fstream &file ){
 
 std::string word;
 
 UINT numSV = 0;
 UINT halfNumClasses = 0;
 numInputDimensions = 0;
 
 //Init the memory for the model
 model = new svm_model;
 model->nr_class = 0;
 model->l = 0;
 model->SV = NULL;
 model->sv_coef = NULL;
 model->rho = NULL;
 model->probA = NULL;
 model->probB = NULL;
 model->label = NULL;
 model->nSV = NULL;
 model->label = NULL;
 model->nSV = NULL;
 model->free_sv = 0; //This will be set to 1 if everything is loaded OK
 
 //Init the memory for the parameters
 model->param.svm_type = 0;
 model->param.kernel_type = 0;
 model->param.degree = 0;
 model->param.gamma = 0;
 model->param.coef0 = 0;
 model->param.cache_size = 0;
 model->param.eps = 0;
 model->param.C = 0;
 model->param.nr_weight = 0;
 model->param.weight_label = NULL;
 model->param.weight = NULL;
 model->param.nu = 0;
 model->param.p = 0;
 model->param.shrinking = 0;
 model->param.probability = 1;
 
 //Load the model type
 file >> word;
 if(word != "ModelType:"){
 errorLog << __GRT_LOG__ << " Failed to find ModelType header!" << std::endl;
 clear();
 return false;
 }
 file >> word;
 if( word == "C_SVC" ){
 model->param.svm_type = C_SVC;
 }else{
 if( word == "NU_SVC" ){
 model->param.svm_type = NU_SVC;
 }else{
 if( word == "ONE_CLASS" ){
 model->param.svm_type = ONE_CLASS;
 }else{
 if( word == "EPSILON_SVR" ){
 model->param.svm_type = EPSILON_SVR;
 }else{
 if( word == "NU_SVR" ){
 model->param.svm_type = NU_SVR;
 }else{
 errorLog << __GRT_LOG__ << " Failed to find SVM type!" << std::endl;
 clear();
 return false;
 }
 }
 }
 }
 }
 
 //Load the model type
 file >> word;
 if(word != "KernelType:"){
 errorLog << __GRT_LOG__ << " Failed to find kernel type!" << std::endl;
 clear();
 return false;
 }
 file >> word;
 if( word == "LINEAR" ){
 model->param.kernel_type = LINEAR;
 }else{
 if( word == "POLYNOMIAL" ){
 model->param.kernel_type = POLY;
 }else{
 if( word == "RBF" ){
 model->param.kernel_type = RBF;
 }else{
 if( word == "SIGMOID" ){
 model->param.kernel_type = SIGMOID;
 }else{
 if( word == "PRECOMPUTED" ){
 model->param.kernel_type = PRECOMPUTED;
 }else{
 errorLog << __GRT_LOG__ << " Failed to find kernel type!" << std::endl;
 clear();
 return false;
 }
 }
 }
 }
 }
 
 //Load the degree
 file >> word;
 if(word != "Degree:"){
 errorLog << __GRT_LOG__ << " Failed to find Degree header!" << std::endl;
 clear();
 return false;
 }
 file >> model->param.degree;
 
 //Load the gamma
 file >> word;
 if(word != "Gamma:"){
 errorLog << __GRT_LOG__ << " Failed to find Gamma header!" << std::endl;
 clear();
 return false;
 }
 file >> model->param.gamma;
 
 //Load the Coef0
 file >> word;
 if(word != "Coef0:"){
 errorLog << __GRT_LOG__ << " Failed to find Coef0 header!" << std::endl;
 clear();
 return false;
 }
 file >> model->param.coef0;
 
 //Load the NumberOfClasses
 file >> word;
 if(word != "NumberOfClasses:"){
 errorLog << __GRT_LOG__ << " Failed to find NumberOfClasses header!" << std::endl;
 clear();
 return false;
 }
 file >> numClasses;
 
 //Load the NumberOfSupportVectors
 file >> word;
 if(word != "NumberOfSupportVectors:"){
 errorLog << __GRT_LOG__ << " Failed to find NumberOfSupportVectors header!" << std::endl;
 clear();
 return false;
 }
 file >> numSV;
 
 //Load the NumberOfFeatures
 file >> word;
 if(word != "NumberOfFeatures:"){
 errorLog << __GRT_LOG__ << " Failed to find NumberOfFeatures header!" << std::endl;
 clear();
 return false;
 }
 file >> numInputDimensions;
 
 //Load the UseShrinking
 file >> word;
 if(word != "UseShrinking:"){
 errorLog << __GRT_LOG__ << " Failed to find UseShrinking header!" << std::endl;
 clear();
 return false;
 }
 file >> model->param.shrinking;
 
 //Load the UseProbability
 file >> word;
 if(word != "UseProbability:"){
 errorLog << __GRT_LOG__ << " Failed to find UseProbability header!" << std::endl;
 clear();
 return false;
 }
 file >> model->param.probability;
 
 //Load the UseScaling
 file >> word;
 if(word != "UseScaling:"){
 errorLog << __GRT_LOG__ << " Failed to find UseScaling header!" << std::endl;
 clear();
 return false;
 }
 file >> useScaling;
 
 //Load the Ranges
 file >> word;
 if(word != "Ranges:"){
 errorLog << __GRT_LOG__ << " Failed to find Ranges header!" << std::endl;
 clear();
 return false;
 }
 //Setup the memory for the ranges
 ranges.clear();
 ranges.resize(numInputDimensions);
 
 for(UINT i=0; i<ranges.size(); i++){
 file >> ranges[i].minValue;
 file >> ranges[i].maxValue;
 }
 
 //Setup the values
 halfNumClasses = numClasses*(numClasses-1)/2;
 model->nr_class = numClasses;
 model->l = numSV;
 
 //Load the RHO
 file >> word;
 if(word != "RHO:"){
 errorLog << __GRT_LOG__ << " Failed to find RHO header!" << std::endl;
 clear();
 return false;
 }
 model->rho = new Float[ halfNumClasses ];
 for(UINT i=0;i<numClasses*(numClasses-1)/2;i++) file >> model->rho[i];
 
 //See if we can load the Labels
 file >> word;
 if(word != "Label:"){
 model->label = NULL;
 }else{
 model->label = new int[ numClasses ];
 for(UINT i=0;i<numClasses;i++) file >> model->label[i];
 //We only need to read a new line if we found the label!
 file >> word;
 }
 
 //See if we can load the ProbA
 //We don't need to read another line here
 if(word != "ProbA:"){
 model->probA = NULL;
 }else{
 model->probA = new Float[ halfNumClasses ];
 for(UINT i=0;i<numClasses*(numClasses-1)/2;i++) file >> model->probA[i];
 //We only need to read a new line if we found the label!
 file >> word;
 }
 
 //See if we can load the ProbB
 //We don't need to read another line here
 if(word != "ProbB:"){
 model->probB = NULL;
 }else{
 model->probB = new Float[ halfNumClasses ];
 for(UINT i=0;i<numClasses*(numClasses-1)/2;i++) file >> model->probB[i];
 //We only need to read a new line if we found the label!
 file >> word;
 }
 
 //See if we can load the NumSupportVectorsPerClass
 //We don't need to read another line here
 if(word != "NumSupportVectorsPerClass:"){
 model->nSV = NULL;
 }else{
 model->nSV = new int[ numClasses ];
 for(UINT i=0;i<numClasses;i++) file >> model->nSV[i];
 //We only need to read a new line if we found the label!
 file >> word;
 }
 
 //Load the SupportVectors
 //We don't need to read another line here
 if(word != "SupportVectors:"){
 errorLog << __GRT_LOG__ << " Failed to find SupportVectors header!" << std::endl;
 clear();
 return false;
 }
 
 //Setup the memory
 model->sv_coef = new Float*[numClasses-1];
 for(UINT j=0;j<numClasses-1;j++) model->sv_coef[j] = new Float[numSV];
 model->SV = new svm_node*[numSV];
 
 for(UINT i=0; i<numSV; i++){
 for(UINT j=0; j<numClasses-1; j++){
 file >> model->sv_coef[j][i];
 }
 
 model->SV[i] = new svm_node[numInputDimensions+1];
 
 if(model->param.kernel_type == PRECOMPUTED) file >> model->SV[i][0].value;
 else{
 for(UINT j=0; j<numInputDimensions; j++){
 file >> model->SV[i][j].index;
 file >> model->SV[i][j].value;
 }
 model->SV[i][numInputDimensions].index = -1; //Assign the final node value
 model->SV[i][numInputDimensions].value = 0;
 }
 }
 
 //Set the class labels
 this->numClasses = getNumClasses();
 classLabels.resize(getNumClasses());
 for(UINT k=0; k<getNumClasses(); k++){
 classLabels[k] = model->label[k];
 }
 
 //The SV have now been loaded so flag that they should be deleted
 model->free_sv = 1;
 
 //Finally, flag that the model has been trained to show it has been loaded and can be used for prediction
 trained = true;
 
 return true;
}

GRT_END_NAMESPACE