SVClustering.h

Go to the documentation of this file.

#ifndef SVCLUSTERING_H_
#define SVCLUSTERING_H_

#include <cmath>
#ifdef linux
        #include <values.h>
#endif

#include <iostream>

#include <boost/config.hpp>
#include <boost/graph/adjacency_matrix.hpp>
#include <boost/graph/graph_utility.hpp>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/connected_components.hpp>

#include <boost/multi_array.hpp>

#include <algorithm>
#include <utility>

#include <bits/stl_pair.h>

#include "ClusteringEngine.h"
#include "OneClassSVM.h"
#include "svm.h"
#include "EuclideanDistance.h"

namespace damina
{

        using namespace boost;
        
        typedef adjacency_matrix<undirectedS> UndirectedGraph;
        
        class SVClustering : public damina::ClusteringEngine
        {
                
                private: 
                        
                        bool clusterizeBSV;

                        long int numberOfClusters;
                        
                        std::vector<unsigned long int> pointPerCluster;
                        
                        std::vector<int> originalClasses;
                        
                        
                        double C;

                
                        double sphereRadius;    
                        
                        double *quadratic;
                        
                        
                        void calculateQuadraticPartOfDistanceFromCenter();

                        
                        // the following inline methods are unused in this child
                        // their implementation is constrained by some abstract anchestors
                        virtual inline void clusterize(DataSet *) {};
                        virtual inline void setTestSet(DataSet *) {};
                        virtual inline DataSet *getTestSet() {return NULL;};


                        
                protected:      
                
                        double C_estimation;
                        
                        
                        OneClassSVM *trainer;
                
                        std::vector<int> labels; 



                        EuclideanDistance *eucDist;     


                        virtual double calculateDistanceFromCenter(struct svm_node *);
                        
                        virtual void calculateSphereRadius();
                        
                        
                        virtual struct svm_node *pointOnThePath(struct svm_node *, struct svm_node *, double); 
                        virtual void separateClusters();
                        
                                
                        virtual double beta(int);
                        virtual double beta(int, bool);
                        
                        virtual double rho();
                        virtual double rho(bool); 
                        

                        
                        
                public:
                                
                        virtual void learn();
                        virtual void learn(DataSet *);
                        virtual void learn(struct svm_problem *);
                        
                        virtual void clusterize();
                        
                        virtual void setTrainingSet(DataSet *);
                        virtual DataSet *getTrainingSet();
                        
                        virtual void setProblem(struct svm_problem *);
                        virtual struct svm_problem *getProblem();
                        
                        virtual struct svm_model *getModel();

                        virtual struct svm_parameter *getParameters();

                        virtual void setSoftConstraint(double);
                        virtual double getSoftConstraint();
                        
                        virtual double getSoftConstraintEstimate();
                        
                        virtual double initialKernelWidth();
                        virtual void setKernelWidth(double);
                        virtual double getKernelWidth();

                        virtual void setKernelType(int);
                        virtual int getKernelType();
                        
                        virtual double getSphereRadius();

                        
                        virtual void setEuclideanDistance(EuclideanDistance *);


                        virtual std::vector<int>& getClustersAssignment();
                        virtual unsigned long int getNumberOfClusters();
                        virtual unsigned long int getNumberOfNonSingletonClusters();
                        virtual unsigned long int getNumberOfValidClusters(unsigned long int);
                        virtual std::vector<unsigned long int>& getPointPerCluster();
                        
                        virtual std::vector<int>& getOriginalClasses(int);
                        
                        virtual void useSpecialClusteringPolicyForBSV();
                        virtual void useClassicClusteringPolicyForBSV();
                        virtual bool usingSpecialClusteringPolicyForBSV();

                        SVClustering(DataSet *);
                        SVClustering(struct svm_problem *);             
                        SVClustering(double, DataSet *);
                        SVClustering(double, struct svm_problem *);
                        SVClustering(double, double, DataSet *);
                        SVClustering(double, double, struct svm_problem *);
                        
                        virtual ~SVClustering();
        };

}

#endif /*SVCLUSTERING_H_*/

---