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 GRT_API 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 GRT_API 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 GRT_API 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