HierarchicalClustering.h

Go to the documentation of this file.

#ifndef GRT_HIERARCHICAL_CLUSTERING_HEADER
#define GRT_HIERARCHICAL_CLUSTERING_HEADER

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

GRT_BEGIN_NAMESPACE
    
class ClusterInfo{
public:
    ClusterInfo(){
        uniqueClusterID = 0;
        clusterVariance = 0;
    }
    ClusterInfo(const ClusterInfo &rhs){
        *this = rhs;
    }
    ~ClusterInfo(){
        
    }
    
    ClusterInfo& operator=(const ClusterInfo &rhs){
        
        if( this != &rhs ){
            this->uniqueClusterID = rhs.uniqueClusterID;
            this->clusterVariance = rhs.clusterVariance;
            this->indexs = rhs.indexs;
        }
        
        return *this;
    }
    
    UINT& operator[](const UINT &i){
        return indexs[i];
    }
    
    UINT operator[](const UINT &i) const{
        return indexs[i];
    }
    
    void addSampleToCluster(UINT i){
        indexs.push_back( i );
    }
    
    UINT getUniqueClusterID() const{
        return uniqueClusterID;
    }
    
    UINT getNumSamplesInCluster() const{
        return (UINT)indexs.size();
    }
    
    Float getClusterVariance() const{
        return clusterVariance;
    }
    
    unsigned int uniqueClusterID;
    Float clusterVariance;
    Vector< UINT > indexs;
};
    
class ClusterLevel{
public:
    ClusterLevel(){
        level = 0;
    }
    
    ClusterLevel(const ClusterLevel &rhs){
        this->level = rhs.level;
        this->clusters = rhs.clusters;
    }
    
    ~ClusterLevel(){
        
    }
    
    ClusterLevel& operator=(const ClusterLevel &rhs){
        
        if( this != &rhs ){
            this->level = rhs.level;
            this->clusters = rhs.clusters;
        }
        
        return *this;
    }
    
    ClusterInfo& operator[](const UINT &i){
        return clusters[i];
    }
    
    ClusterInfo operator[](const UINT &i) const{
        return clusters[i];
    }
    
    UINT getLevel() const{
        return level;
    }
    
    UINT getNumClusters() const{
        return (UINT)clusters.size();
    }
    
    unsigned int level;
    Vector< ClusterInfo > clusters;
};

class HierarchicalClustering : public Clusterer {

public:
 HierarchicalClustering();
    
    HierarchicalClustering(const HierarchicalClustering &rhs);
    
    virtual ~HierarchicalClustering();
    
    HierarchicalClustering &operator=(const HierarchicalClustering &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 saveModelToFile( std::fstream &file ) const;
    
    virtual bool loadModelFromFile( std::fstream &file );
    
    bool printModel();
    
    Vector< ClusterLevel > getClusters(){ return clusters; }
    
    //Tell the compiler we are using the base class train method to stop hidden virtual function warnings
    using MLBase::saveModelToFile;
    using MLBase::loadModelFromFile;

protected:
 inline Float SQR(const Float &a) {return a*a;};
    Float squaredEuclideanDistance(const Float *a,const Float *b);
    Float computeClusterDistance( const ClusterInfo &clusterA, const ClusterInfo &clusterB );
    Float computeClusterVariance( const ClusterInfo &cluster, const MatrixFloat &data );

 UINT M;                             //Number of training examples
 UINT N;                             //Number of dimensions
    Vector< ClusterLevel > clusters;
    MatrixFloat distanceMatrix;                     //The distance matrix

private:
    static RegisterClustererModule< HierarchicalClustering > registerModule;
  
};
    
GRT_END_NAMESPACE

#endif //GRT_HIERARCHICAL_CLUSTERING_HEADER