GaussianMixtureModels.h

Go to the documentation of this file.

#ifndef GRT_GAUSSIAN_MIXTURE_MODELS_HEADER
#define GRT_GAUSSIAN_MIXTURE_MODELS_HEADER

#include "../../CoreModules/Clusterer.h"

GRT_BEGIN_NAMESPACE

class GaussianMixtureModels : public Clusterer
{
public:
 GaussianMixtureModels(const UINT numClusters=10,const UINT minNumEpochs=5,const UINT maxNumEpochs=1000,const Float minChange=1.0e-5);
    
    GaussianMixtureModels(const GaussianMixtureModels &rhs);
    
 virtual ~GaussianMixtureModels();
    
    GaussianMixtureModels &operator=(const GaussianMixtureModels &rhs);
    
    virtual bool deepCopyFrom(const Clusterer *clusterer);
    
    virtual bool reset();
    
    virtual bool clear();
    
    virtual bool train_(MatrixFloat &trainingData);
    
    virtual bool train_(ClassificationData &trainingData);
    
 virtual bool train_(UnlabelledData &trainingData);
    
    
    virtual bool predict_(VectorDouble &inputVector);
    
    virtual bool saveModelToFile( std::fstream &file ) const;
    
    virtual bool loadModelFromFile( std::fstream &file );
    
    MatrixFloat getMu() const { if( trained ){ return mu; } return MatrixFloat(); }
    
    Vector< MatrixFloat > getSigma() const { if( trained ){ return sigma; } return Vector< MatrixFloat >(); }
    
    MatrixFloat getSigma(const UINT k) const{
        if( k < numClusters && trained ){
            return sigma[k];
        }
        return MatrixFloat();
    }
    
    //Tell the compiler we are using the base class train method to stop hidden virtual function warnings
    using MLBase::saveModelToFile;
    using MLBase::loadModelFromFile;
 
protected:
    bool estep( const MatrixFloat &data, VectorDouble &u, VectorDouble &v, Float &change );
 bool mstep( const MatrixFloat &data );
 bool computeInvAndDet();
 inline void SWAP(UINT &a,UINT &b);
 inline Float SQR(const Float v){ return v*v; }
    
    Float gauss(const VectorDouble &x,const UINT clusterIndex,const VectorDouble &det,const MatrixFloat &mu,const Vector< MatrixFloat > &invSigma){
        
        Float y = 0;
        Float sum = 0;
        UINT i,j = 0;
        const UINT N = (UINT)x.size();
        VectorDouble temp(N,0);
        
        //Compute the first part of the equation
        y = (1.0/pow(TWO_PI,N/2.0)) * (1.0/pow(det[clusterIndex],0.5));
        
        //Compute the later half
        for(i=0; i<N; i++){
            for(j=0; j<N; j++){
                temp[i] += (x[j]-mu[clusterIndex][j]) * invSigma[clusterIndex][j][i];
            }
            sum += (x[i]-mu[clusterIndex][i]) * temp[i];
        }
        
        return ( y*exp( -0.5*sum ) );
    }
    
 UINT numTrainingSamples;                    
 Float loglike;                             
 MatrixFloat mu;                            
 MatrixFloat resp;                          
 VectorDouble frac;                          
 VectorDouble lndets;                        
 VectorDouble det;                         
 Vector< MatrixFloat > sigma;
 Vector< MatrixFloat > invSigma;
    
private:
    static RegisterClustererModule< GaussianMixtureModels > registerModule;
};
    
GRT_END_NAMESPACE

#endif //GRT_GAUSSIAN_MIXTURE_MODELS_HEADER