MinDistModel.cpp

#include "MinDistModel.h"

GRT_BEGIN_NAMESPACE

MinDistModel::MinDistModel(){
    classLabel = 0;
    numFeatures = 0;
    numClusters = 0;
    rejectionThreshold = 0;
    gamma = 0;
    trainingMu = 0;
    trainingSigma = 0;
}
    
MinDistModel::MinDistModel(const MinDistModel &rhs){

    this->classLabel = rhs.classLabel;
    this->numFeatures = rhs.numFeatures;
    this->numClusters = rhs.numClusters;
    this->rejectionThreshold = rhs.rejectionThreshold;
    this->gamma = rhs.gamma;
    this->trainingMu = rhs.trainingMu;
    this->trainingSigma = rhs.trainingSigma;
    this->clusters = rhs.clusters;
}
    
MinDistModel::~MinDistModel(void){}
    
MinDistModel& MinDistModel:: operator=(const MinDistModel &rhs){
 if( this != &rhs ){
        //MinDistModel variables
  this->classLabel = rhs.classLabel;
  this->numFeatures = rhs.numFeatures;
  this->numClusters = rhs.numClusters;
  this->rejectionThreshold = rhs.rejectionThreshold;
  this->gamma = rhs.gamma;
  this->trainingMu = rhs.trainingMu;
  this->trainingSigma = rhs.trainingSigma;
  this->clusters = rhs.clusters;
 }
 return *this;
}
 
bool MinDistModel::train(UINT classLabel,MatrixFloat &trainingData,UINT numClusters,Float minChange,UINT maxNumEpochs){
 
 if( trainingData.getNumRows() < numClusters ){
        return false;
    }
 
 this->classLabel = classLabel;
 this->numFeatures = trainingData.getNumCols();
 this->numClusters = numClusters;
 
 //Find the clusters
 KMeans kmeans;
    kmeans.setNumClusters(numClusters);
 kmeans.setMinChange( minChange );
 kmeans.setMaxNumEpochs( maxNumEpochs );
 
 if( !kmeans.train_(trainingData) ){
  return false;
 }
 
 clusters = kmeans.getClusters();
    
 //Compute the rejection thresholds
 rejectionThreshold = 0;
 trainingMu = 0;
 trainingSigma = 0;
    
    //Now compute the rejection threshold
    const UINT M = trainingData.getNumRows();
    const UINT N = trainingData.getNumCols();
 VectorFloat predictions(M);
 for(UINT i=0; i<M; i++){
  //Test the ith training example
  VectorFloat testData(N);
  for(UINT j=0; j<N; j++) {
   testData[j] = trainingData[i][j];
        }
        
  predictions[i] = predict( testData );
        trainingMu += predictions[i];
 }
    
 //Calculate the mean prediction value
 trainingMu /= Float(M);
    
 //Calculate the standard deviation
 for(UINT i=0; i<M; i++) {
  trainingSigma += SQR( predictions[i]-trainingMu );
    }
 trainingSigma = sqrt( trainingSigma / (Float(M)-1.0) );
    
 rejectionThreshold = trainingMu + ( trainingSigma * gamma );
 return true;
 
}

Float MinDistModel::predict(const VectorFloat &inputVector){
 
 Float minDist = grt_numeric_limits< Float >::max();
 Float dist = 0;
 
 for(UINT k=0; k<numClusters; k++){
  dist = 0;
        for(UINT n=0; n<numFeatures; n++){
            dist += SQR( clusters[k][n]-inputVector[n] );
        }
  if( dist < minDist )
   minDist = dist;
 }
    
    //Only compute the sqrt for the minimum distance
 return sqrt( minDist );
     
    return minDist;
}
 
void MinDistModel::recomputeThresholdValue(){
 rejectionThreshold = trainingMu + ( trainingSigma * gamma );
}
 
UINT MinDistModel::getClassLabel() const{
 return classLabel;
}

UINT MinDistModel::getNumFeatures() const{
 return numFeatures;
}

UINT MinDistModel::getNumClusters() const{
 return numClusters;
}
    
Float MinDistModel::getRejectionThreshold() const{
    return rejectionThreshold;
}

Float MinDistModel::getGamma() const{
    return gamma;
}
    
Float MinDistModel::getTrainingMu() const{
    return trainingMu;
}
    
Float MinDistModel::getTrainingSigma() const{
    return trainingSigma;
}

MatrixFloat MinDistModel::getClusters() const{
 return clusters;
}
    
bool MinDistModel::setClassLabel(UINT classLabel){
    this->classLabel = classLabel;
    return true;
}

bool MinDistModel::setClusters(MatrixFloat &clusters){
    this->clusters = clusters;
 this->numClusters = clusters.getNumRows();
 this->numFeatures = clusters.getNumCols();
    return true;
}

bool MinDistModel::setGamma(Float gamma){
    this->gamma = gamma;
    return true;
}

bool MinDistModel::setRejectionThreshold(Float rejectionThreshold){
    this->rejectionThreshold = rejectionThreshold;
    return true;
}

bool MinDistModel::setTrainingSigma(Float trainingSigma){
    this->trainingSigma = trainingSigma;
    return true;
}

bool MinDistModel::setTrainingMu(Float trainingMu){
    this->trainingMu = trainingMu;
    return true;
}

GRT_END_NAMESPACE