MixtureModel.h

Go to the documentation of this file.

#ifndef GRT_MIXTURE_MODEL_HEADER
#define GRT_MIXTURE_MODEL_HEADER

#include "../../CoreModules/Classifier.h"
#include "../../ClusteringModules/GaussianMixtureModels/GaussianMixtureModels.h"

GRT_BEGIN_NAMESPACE
    
class GuassModel{
public:
    GuassModel(){
        det = 0;
    }
    
    ~GuassModel(){
        
    }
    
    bool printModelValues() const{
        if( mu.size() == 0 ) return false;
        
        std::cout << "Determinate: " << det << std::endl;
        std::cout << "Mu: ";
        for(UINT i=0; i<mu.getSize(); i++)
            std::cout << mu[i] << "\t";
        std::cout << std::endl;
        
        std::cout << "Sigma: \n";
        for(UINT i=0; i<sigma.getNumRows(); i++){
            for(UINT j=0; j<sigma.getNumCols(); j++){
                std::cout << sigma[i][j] << "\t";
            }std::cout << std::endl;
        }std::cout << std::endl;
        
        std::cout << "InvSigma: \n";
        for(UINT i=0; i<invSigma.getNumRows(); i++){
            for(UINT j=0; j<invSigma.getNumCols(); j++){
                std::cout << invSigma[i][j] << "\t";
            }std::cout << std::endl;
        }std::cout << std::endl;
        
        return true;
    }
    
    Float det;
    VectorFloat mu;
    MatrixFloat sigma;
    MatrixFloat invSigma;
};
    
class MixtureModel{
public:
    MixtureModel(){
        classLabel = 0;
        K = 0;
        normFactor = 1;
        nullRejectionThreshold = 0;
        trainingMu = 0;
        trainingSigma = 0;
        gamma = 1;
    }
    ~MixtureModel(){
        gaussModels.clear();
    }
    
    inline GuassModel& operator[](const UINT i){
        return gaussModels[i];
 }
    
    inline const GuassModel& operator[](const UINT i) const{
        return gaussModels[i];
 }
    
    Float computeMixtureLikelihood( const VectorFloat &x ){
        Float sum = 0;
        for(UINT k=0; k<K; k++){
            sum += gauss(x,gaussModels[k].det,gaussModels[k].mu,gaussModels[k].invSigma);
        }
        //Normalize the mixture likelihood
        return sum/normFactor;
    }
    
    bool resize(UINT K){
        if( K > 0 ){
            this->K = K;
            gaussModels.clear();
            gaussModels.resize(K);
            return true;
        }
        return false;
    }
    
    bool recomputeNullRejectionThreshold(Float gamma){
        Float newRejectionThreshold = 0;
        //TODO - Need a way of improving the null rejection threshold for the GMMs!!!!
        newRejectionThreshold = trainingMu - (trainingSigma*gamma);
        newRejectionThreshold = 0.02;
        
        //Make sure that the new rejection threshold is greater than zero
        if( newRejectionThreshold > 0 ){
            this->gamma = gamma;
            this->nullRejectionThreshold = newRejectionThreshold;
            return true;
        }
        return false;
    }
    
    bool recomputeNormalizationFactor(){
        normFactor = 0;
        for(UINT k=0; k<K; k++){
            normFactor += gauss(gaussModels[k].mu,gaussModels[k].det,gaussModels[k].mu,gaussModels[k].invSigma);
        }
        return true;
    }
    
    bool printModelValues() const{
        if( gaussModels.getSize() > 0 ){
            for(UINT k=0; k<gaussModels.getSize(); k++){
                gaussModels[k].printModelValues();
            }
        }
        return false;
    }
    
    UINT getK() const { return K; }
    
    UINT getClassLabel() const { return classLabel; }
    
    Float getTrainingMu() const {
        return trainingMu;
    }
    
    Float getTrainingSigma() const {
        return trainingSigma;
    }
    
    Float getNullRejectionThreshold() const {
        return nullRejectionThreshold;
    }
    
    Float getNormalizationFactor() const {
        return normFactor;
    }
    
    bool setClassLabel(const UINT classLabel){
        this->classLabel = classLabel;
        return true;
    }
    
    bool setNormalizationFactor(const Float normFactor){
        this->normFactor = normFactor;
        return true;
    }
    
    bool setTrainingMuAndSigma(const Float trainingMu,const Float trainingSigma){
        this->trainingMu = trainingMu;
        this->trainingSigma = trainingSigma;
        return true;
    }
    
    bool setNullRejectionThreshold(const Float nullRejectionThreshold){
        this->nullRejectionThreshold = nullRejectionThreshold;
        return true;
    }
    
private:    
    Float gauss(const VectorFloat &x,Float det,const VectorFloat &mu,const MatrixFloat &invSigma){
        
        Float y = 0;
        Float sum = 0;
        const UINT N = x.getSize();
        VectorFloat temp(N,0);
        
        //Compute the first part of the equation
        y = (1.0/pow(TWO_PI,N/2.0)) * (1.0/pow(det,0.5));
        
        //Compute the later half    
        for(UINT i=0; i<N; i++){
            for(UINT j=0; j<N; j++){
                temp[i] += (x[j]-mu[j]) * invSigma[j][i];
            }
            sum += (x[i]-mu[i]) * temp[i];
        }
        
        return ( y*grt_exp( -0.5*sum ) );
    }
    
    UINT classLabel;
    UINT K;
    Float nullRejectionThreshold;
    Float gamma;                           //The number of standard deviations to use for the threshold
 Float trainingMu;                      //The average confidence value in the training data
 Float trainingSigma;                   //The simga confidence value in the training data
    Float normFactor;
    Vector< GuassModel > gaussModels;
    
};
    
GRT_END_NAMESPACE

#endif //GRT_MIXTURE_MODEL_HEADER