MMSD_Model.h

Go to the documentation of this file.

#ifndef MMSD_Model_H
#define MMSD_Model_H

#include "CORE_File.h"

#include "MMSD_Object.h"

#include "MMSD_DataSet.h"
#include "MMSD_Cluster.h"
#include "MMSD_DoubleVector.h"
#include "CORE_ClassFactory.h"

DEFINE_SPTR(MMSD_Model);
class MMSD_Model : public virtual MMSD_Object {
    SP_OBJECT(MMSD_Model);
    // ATTRIBUTES
  

private:
    tBoolean mIsEmptyClusterDeleted;
    
    tString mWeightInitType;
    double mWeightInitScale;
    double mWeightInitRate;
    
    // max iterations number
    int mEMMaximumIterationsNumber;
    
    // effective iterations number
    int mEMIterationsNumber;
    
    
    // data set whose properties is of size N x P & clusters of size N
    SP::MMSD_DataSet mDataSet;
    
    // clusters
    // store for backup
    SV::MMSD_Cluster mClusters;
    
    MMSD_IntegerVector mSampleClusterIndices;
    MMSD_DoubleFullMatrix mSampleClusterProbabilities;

    
    // logL
    MMSD_DoubleVector mLogL;
    
    // computing variables
    MMSD_DoubleVector mWork;// size nThreads*nSamples


    // min eigen value for diagonal
    double mMinEigenValue;
    

  
  
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    MMSD_Model(void);
  
  
  
    // DESTRUCTORS 
  
  
    virtual ~MMSD_Model(void);   
  
  
  
public:
    //----------------
    // NEW constructors
    // ---------------
    

    // -----------------
    // SET & GET Methods
    // -----------------
public:
    inline void setIsEmptyClusterDeleted(const tBoolean& v) {
        mIsEmptyClusterDeleted=v;
    }
    inline void setDataSet(SP::MMSD_DataSet data) {
        mDataSet=data;
    };
    inline const MMSD_DataSet* getDataSet() const {
        return mDataSet.get();
    };
    inline  MMSD_DataSet* getDataSet()  {
        return mDataSet.get();
    };

    inline void setEMMaximumIterationsNumber(const int& n) {
        mEMMaximumIterationsNumber=n;
    };
    inline int getEMMaximumIterationsNumber() const {
        return mEMMaximumIterationsNumber;
    };

    inline int getEMIterationsNumber() const {
        return mEMIterationsNumber;
    };
  

 
   

    inline tVectorIndex getClustersNumber() const {
        return mClusters.getSize();
    };


    inline const MMSD_Cluster* getCluster(const tVectorIndex& index) const {
        if ((index>=0) && (index<mClusters.getSize())) return mClusters.get(index);
        return null;
    }

    inline const MMSD_DoubleFullMatrix&  getSampleClusterProbabilities() const {
        return mSampleClusterProbabilities;
    };
    inline const MMSD_IntegerVector & getSampleClusterIndices() const {
        return mSampleClusterIndices;
    };

    inline void setMinEigenValue(const double& v) {mMinEigenValue=v;};
    inline double getMinEigenValue() const {return mMinEigenValue;};
    
    
    virtual SP::MMSD_Cluster NewClusterInstance() const=0;

    virtual SP::MMSD_Law NewLawInstance() const=0;

    

    inline void setWeightInitializationType(const tString& type,const double& scale, const double& rate) {
        mWeightInitType=type;
        mWeightInitScale=scale;
        mWeightInitRate=rate;
    }  
    // -----------------
    // Optimization Mehod
    // -----------------
   
    
public:
    tBoolean parametersOptimizationByEMMethod(const int& nClusters,
                                              const MMSD_IntegerVector& sampleClusters,
                                              const tString& backupPath,
                                              const tString& backupPrefix,
                                              const int& nDigits,
                                              const int& backupSteps);

    inline tBoolean parametersOptimizationByEMMethod(const int& nClusters,
                                                     const MMSD_IntegerVector& sampleClusters) {
        return parametersOptimizationByEMMethod(nClusters,sampleClusters,
                                                "","",0,-1);
    };
    inline tBoolean parametersOptimizationByEMMethod() {
        MMSD_IntegerVector sampleClusters;
        return parametersOptimizationByEMMethod(0,sampleClusters,"","",0,-1);
    };
    inline tBoolean parametersOptimizationByEMMethod( const tString& backupPath,
                                                      const tString& backupPrefix,
                                                      const int& nDigits,
                                                      const int& backupSteps) {
        MMSD_IntegerVector sampleClusters;
        return parametersOptimizationByEMMethod(0,sampleClusters,backupPath,backupPrefix,nDigits,backupSteps);
    };
    
  
  

    inline tBoolean restore(SP::CORE_ClassFactory factory,
                            const tString& backupPath,
                            const tString& backupPrefix,
                            const int& nDigits,const int& step) {
        tString file=backupPath+CORE_File::PATH_SEPARATOR+backupPrefix+CORE_Integer::toString(step,nDigits)+".R";
        return restore(factory,file);
    }
    
    tBoolean  restore(SP::CORE_ClassFactory factory,const tString& file);

    
    
protected:

    virtual void restore(const MMSD_DoubleFullMatrix& properties);
    
    virtual void initialize(const MMSD_IntegerVector& clusters,
                            const MMSD_DoubleFullMatrix& properties,
                            const int& nClusters);

public:
    void computeSampleClusterProbabilities(MMSD_DoubleFullMatrix& P, MMSD_DoubleVector& work) const;
    
    void computeSampleClusterProbabilities() {
        computeSampleClusterProbabilities(mSampleClusterProbabilities,mWork);
    }
    
    void computeSampleClusterIndices(MMSD_DoubleVector& work,
                                     MMSD_IntegerVector& indices) const;

    tBoolean esperanceEvaluation();
    
    tBoolean esperanceMaximization();
    tBoolean hasConverged() const;
public:
    tBoolean computeLogLikelihood(double& logL) {
        return computeLogLikelihood(mWork,logL);
    }
private:
    tBoolean computeLogLikelihood(MMSD_DoubleVector& sumExpPk,double& logL) const;

public:
    const MMSD_DoubleVector& getLogL() const {
        return mLogL;
    }
    
    // ------------------------------
    // SAVER & LOADER for UI class
    // ------------------------------
    virtual void saveToUIClass(UI_Class& mclass) const;

    virtual void loadFromUIClass(const UI_Class& mclass);
    // ----------------------
    // String representation
    // ----------------------
public:
    virtual tString toString() const {
        tString ret=MMSD_Object::toString();
        return ret;
    }
    
    
};

#endif