damina::CCLSVClustering Class Reference

An implementation of the Support Vector Clustering originally proposed by Ben-Hur et al (2001), with a variation in the Cluster Labeling part. More...

#include <CCLSVClustering.h>

Inheritance diagram for damina::CCLSVClustering:

[legend]Collaboration diagram for damina::CCLSVClustering:

[legend]List of all members.

Public Member Functions
	CCLSVClustering (double, double, struct svm_problem *)
	Constructor.
	CCLSVClustering (double, double, DataSet *)
	Constructor.
	CCLSVClustering (double, struct svm_problem *)
	Constructor.
	CCLSVClustering (double, DataSet *)
	Constructor.
	CCLSVClustering (struct svm_problem *)
	Constructor.
	CCLSVClustering (DataSet *)
	Constructor.
virtual void	clusterize ()
	Run the clustering process.
virtual std::vector< int > &	getClustersAssignment ()
	Returns the clustering assignments.
virtual int	getKernelType ()
	Returns the current kernel type.
virtual double	getKernelWidth ()
	Returns the current value of the Kernel Width.
virtual struct svm_model *	getModel ()
	Returns the trained model.
virtual unsigned long int	getNumberOfClusters ()
	Returns the number of clusters found.
virtual unsigned long int	getNumberOfNonSingletonClusters ()
	Returns the number of clusters containing more than one point.
virtual unsigned long int	getNumberOfValidClusters (unsigned long int)
	Returns the number of clusters with a number of elements greater than or equal to a certain threshold.
virtual std::vector< int > &	getOriginalClasses (int)
	Returns the original classes assignments for the points in input.
virtual struct svm_parameter *	getParameters ()
	Returns the SVM paramters.
virtual std::vector< unsigned long int > &	getPointPerCluster ()
	Returns the number of points per cluster.
virtual struct svm_problem *	getProblem ()
	Returns the current input data set in the libsvm format.
virtual double	getSoftConstraint ()
	Returns the current value of the Soft Margin Constraint.
virtual double	getSoftConstraintEstimate ()
	Return the estimate of a more appropriate Soft Margin parameter.
virtual double	getSphereRadius ()
	Returns the current value of the sphere radius.
virtual DataSet *	getTrainingSet ()
	Returns the current input data set.
virtual double	initialKernelWidth ()
	Computes the initial gaussian kernel width, as proposed in.
virtual void	learn (struct svm_problem *)
	The learning process.
virtual void	learn (DataSet *)
	The learning process.
virtual void	learn ()
	The learning process.
virtual void	setEuclideanDistance (EuclideanDistance *)
	Set a vector-distance measure valid for the Euclidean Space.
virtual void	setKernelType (int)
	Set the kernel type for the SVM.
virtual void	setKernelWidth (double)
	Set the new width for Gaussian Kernel.
virtual void	setProblem (struct svm_problem *)
	Set the input data set in libsvm format.
virtual void	setSoftConstraint (double)
	Set the new value for the Soft Margin Constant.
virtual void	setTrainingSet (DataSet *)
	Set the input data set.
virtual void	useClassicClusteringPolicyForBSV ()
	Use the classic clustering policy to clusterize BSVs.
virtual void	useSpecialClusteringPolicyForBSV ()
	Use a special clustering policy to clusterize BSVs.
virtual bool	usingSpecialClusteringPolicyForBSV ()
	Return true if the SVC is using the special policy to clusterize BSV.
virtual	~CCLSVClustering ()
	Destructor.
Protected Member Functions
virtual double	beta (int, bool)
	Returns the i-th lagrangian multiplier.
virtual double	beta (int)
	Returns the i-th lagrangian multiplier.
virtual double	calculateDistanceFromCenter (struct svm_node *)
	Calculate the distance of a point from the center of the sphere.
virtual void	calculateSphereRadius ()
	Calculate the sphere radius.
virtual void	experimentalSeparateClusters ()
virtual double	rho (bool)
	Returns the rho value of the decision function computed by One Class SVM.
virtual double	rho ()
	Returns the rho value of the decision function computed by One Class SVM.
virtual void	separateClusters ()
	Run the clustering process.
Protected Attributes
double	C_estimation
	An estimation of a more appropriate C value, based on the heuristics proposed in the last paragraph of.
EuclideanDistance *	eucDist
	Euclidean Measure for compute distance between vectors.
std::vector< int >	labels
	Clustering assignments.
OneClassSVM *	trainer
	The One Class SVM for the first step of the SV Clustering process.
Private Member Functions
void	calculateZeta ()
	Calculate the Zeta, i.e.
void	clusterizeBSVs ()
svm_node *	pointOnThePath (struct svm_node *, struct svm_node *, double)
	Samples a point on the path between two points.
Private Attributes
double	zeta

---

Detailed Description

An implementation of the Support Vector Clustering originally proposed by Ben-Hur et al (2001), with a variation in the Cluster Labeling part.

This class implements the Support Vector Clustering originally proposed in

A. Ben-Hur, D. Horn, H. T. Siegelmann, and V. Vapnik, "Support Vector Clustering," Journal of Machine Learning Research, vol. 2, pp. 125-137, 2001.

The Support Vector Clustering is among the few attempts to use the SVMs in an unsupervised way.

It consists mainly of two steps:

1. Cluster description
=======================

Find the Minimum Enclosing Sphere in the feature space, exactly as SVDD described in

D. M. J. Tax and R. P. W. Duin, "Data Domain Description using Support Vectors," in European Symposium on Artificial Neural Network, Bruges (Belgium), 1999.

D. M. J. TAX, "One-class classification: concept learning in the absence of counter-examples," PhD Thesis , 2001.

This leads to a Quadratic Programming problem like in the classic SVM training problem

This sphere, mapped back to the data space, split in various contours, each representing a cluster.

Here, we use One-class classification by Schoelkopf et al (2001) instead of SVDD by Tax.

The two methods are showed to be equivalent under following conditions:
a. The kernel must be Gaussian Kernel
b. The kernel width must be the same
c. The C parameter in SVDD must be equal to 1/(nu*N), where nu is the parameter in One-class SVM and N is the number of input elements.

The conditions a. is satisfied because the Support Vector Clustering formulation was based on the Gaussian Kernel (due the other kernels, like polynomial one, not describe the cluster boundaries well, as showed by Tax & Duin 1999)

2. Cluster labeling
===================

The cluster description algorithm does not differentiate between points that belong to differ- ent clusters.

Here we replace the originally proposed cluster labeling algorithm with a novel and faster method proposed in

S. Lee and K. M. Daniels, "Cone Cluster Labeling for Support Vector Clustering," in Proceedings of 6th SIAM Conference on Data Mining, 2006, pp. 484-488.

See also:

OneClassSVM

Author:

Vincenzo Russo - vincenzo.russo@neminis.org

Definition at line 70 of file CCLSVClustering.h.

---

Constructor & Destructor Documentation

damina::CCLSVClustering::CCLSVClustering

(

DataSet *

train

)

Constructor.

Parameters:

train

The input data set

Definition at line 12 of file CCLSVClustering.cpp.

                                                      : SVClustering(train) {
        }

damina::CCLSVClustering::CCLSVClustering

(

struct svm_problem *

p

)

Constructor.

Parameters:

p

The input data in libsvm format

Definition at line 20 of file CCLSVClustering.cpp.

                                                             : SVClustering(p) {
                
        }

damina::CCLSVClustering::CCLSVClustering	(	double	C,
		DataSet *	train
	)

Constructor.

Parameters:

	C	The soft margin constant
	train	The input data set

Definition at line 30 of file CCLSVClustering.cpp.

                                                                : SVClustering(C, train) {
                
        }

damina::CCLSVClustering::CCLSVClustering	(	double	C,
		struct svm_problem *	p
	)

Constructor.

Parameters:

	C	The soft margin constant
	prob	The input data set in libsvm format

Definition at line 40 of file CCLSVClustering.cpp.

                                                                       : SVClustering(C, p) {
                
        }

damina::CCLSVClustering::CCLSVClustering	(	double	C,
		double	w,
		DataSet *	train
	)

Constructor.

Parameters:

	C	The soft margin constant
	w	The gaussian kernel width
	train	The input data set

Definition at line 51 of file CCLSVClustering.cpp.

                                                                          : SVClustering(C, w, train) {
                
        }

damina::CCLSVClustering::CCLSVClustering	(	double	C,
		double	w,
		struct svm_problem *	p
	)

Constructor.

Parameters:

	C	The soft margin constant
	w	The gaussian kernel width
	prob	The input data set in libsvm format

Definition at line 62 of file CCLSVClustering.cpp.

                                                                                 : SVClustering(C, w, p) {
                
        }

damina::CCLSVClustering::~CCLSVClustering

(

)

[virtual]

Destructor.

Definition at line 71 of file CCLSVClustering.cpp.

                                                {
                 
        }

---

Member Function Documentation

double damina::SVClustering::beta	(	int	i,
		bool	scaled
	)			[protected, virtual, inherited]

Returns the i-th lagrangian multiplier.

The One Class SVM solves the Quadratic Programming problem and computes the lagrangians "beta". LibSVM solves a scaled version of the One Class SVM problem, so this method returns either the scaled value of a beta or the normal one, depeding on the 'scaled' param.

To obtain the normal value of a lagrangian, we multiply it by C.

The betas equal to zero (non-support vector ones) are not in the solution.

Parameters:

	i	The index of the lagrangian
	scaled	True if you want the scaled version, false otherwise

Returns:

The value of the i-th beta (scaled or not, depending on 'scaled' param)

Definition at line 590 of file SVClustering.cpp.

References damina::OneClassSVM::getModel(), damina::SVClustering::getSoftConstraint(), and damina::SVClustering::trainer.

                                                    {
                if (scaled) {
                        return this->trainer->getModel()->sv_coef[0][i];
                }
                else {
                        return this->trainer->getModel()->sv_coef[0][i] * getSoftConstraint();
                }
        }

Here is the call graph for this function:

double damina::SVClustering::beta

(

int

i

)

[protected, virtual, inherited]

Returns the i-th lagrangian multiplier.

The One Class SVM solves the Quadratic Programming problem and computes the lagrangians "beta". This method returns the i-th beta, multiplied by C, because LibSVM solves a scaled version of the One Class SVM problem. The betas equal to zero (non-support vector ones) are not in the solution.

Parameters:

i

The index of the lagrangian

Returns:

The value of the i-th beta

Definition at line 569 of file SVClustering.cpp.

References damina::SVClustering::C, damina::OneClassSVM::getModel(), and damina::SVClustering::trainer.

Referenced by damina::SVClustering::calculateDistanceFromCenter(), damina::SVClustering::calculateQuadraticPartOfDistanceFromCenter(), experimentalSeparateClusters(), and separateClusters().

                                        {
                return this->trainer->getModel()->sv_coef[0][i] * C; 
         }

Here is the call graph for this function:

Here is the caller graph for this function:

double damina::SVClustering::calculateDistanceFromCenter

(

struct svm_node *

x

)

[protected, virtual, inherited]

Calculate the distance of a point from the center of the sphere.

Reference:

A. Ben-Hur, D. Horn, H. T. Siegelmann, and V. Vapnik, "Support Vector Clustering," Journal of Machine Learning Research, vol. 2, pp. 125-137, 2001.

The Equation nr. 13 in the paper above is the distance of a point from the center of Sphere

We sum over support vectors only (including Bounded SVs), because the Betas (lagrangian multipliers) are zero for non-SVs.

Furthermore, we replace K(x,x) with 1, because with the Gaussian Kernel, K(x,x) = 1 for all x.

See also:

calculateQuadraticPartOfDistanceFromCenter()

Parameters:

x

The point

Definition at line 695 of file SVClustering.cpp.

References damina::SVClustering::beta(), damina::SVClustering::calculateQuadraticPartOfDistanceFromCenter(), damina::OneClassSVM::getModel(), and damina::SVClustering::trainer.

Referenced by damina::SVClustering::calculateSphereRadius(), and damina::SVClustering::separateClusters().

                                                                           {
                double sum = 0;
                
                struct svm_node **SV = this->trainer->getModel()->SV;
                int nSV = this->trainer->getModel()->l;
                
                
                for (int i = 0; i < nSV; i++) {
                        sum += beta(i) * kernelfunction(SV[i], x, this->trainer->getModel()->param);
                }
                
                
                calculateQuadraticPartOfDistanceFromCenter();
                
                // 1 is because (in case of RBF kernel used here) K(x,x) is equal to 1 
                // (therotically provable and pratically tested with libsvm) 
                //return sqrt(1 - (2 * sum) + *(this->quadratic));
                return 1 - (2 * sum) + *(this->quadratic);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

void damina::SVClustering::calculateSphereRadius

(

)

[protected, virtual, inherited]

Calculate the sphere radius.

Reference:

A. Ben-Hur, D. Horn, H. T. Siegelmann, and V. Vapnik, "Support Vector Clustering," Journal of Machine Learning Research, vol. 2, pp. 125-137, 2001.

Equation nr. 14 in the paper above is radius of the Sphere.

As suggested in

J. Yang, V. Estivill-Castro, and S. K. Chalup, "Support vector clustering through proximity graph modelling," in Neural Information Processing, 2002. ICONIP ‘02. Proceedings of the 9th International Conference on, 2002, pp. 898-903.

we can use the average among SVs' distances from center to calculate the radius.

However, theoretically, all the SVs must have the same distance from center, so we have tested and found that using the distance of just one SV is a good approximation as much as to compute the aforementioned average.

This solution avoids to compute the distance for all SVs.

Definition at line 741 of file SVClustering.cpp.

References damina::SVClustering::calculateDistanceFromCenter(), and damina::SVClustering::sphereRadius.

Referenced by damina::SVClustering::getSphereRadius().

                                                 {
                
                // first tecnique
                //
                // assuming SVs have all the same distanace from center (theoretically a correct assumption)
                // to avoid a check on the distance of all SVs
                //
                this->sphereRadius = this->calculateDistanceFromCenter(this->trainer->getModel()->SV[0]);
                
                //if (this->sphereRadius >= 1) {
                //      free(quadratic);
                //      this->sphereRadius = this->calculateDistanceFromCenter(this->trainer->getModel()->SV[0]);
                //}

                // second tecnique
                //
                // we can use the average among SVs' distances to calculate the radius
                
                //int nSV = this->trainer->getModel()->l;
                //this->sphereRadius = 0;
                //for (int i = 0; i < nSV; i++) {
                //      this->sphereRadius += this->calculateDistanceFromCenter(this->trainer->getModel()->SV[i]);                      
                //}
                //this->sphereRadius = this->sphereRadius / nSV;

                //      third tecnique
                //      Using One Class SVM, Radius = sqrt(1 - rho/2)
                //sphereRadius = sqrt(1 - (rho()/2));
        }

Here is the call graph for this function:

Here is the caller graph for this function:

void damina::CCLSVClustering::calculateZeta

(

)

[private]

Calculate the Zeta, i.e.

the radius of the SV-centered spheres in data space, corresponding to Support Vector Cones in features space, as described in

S. Lee and K. M. Daniels, "Cone Cluster Labeling for Support Vector Clustering," in Proceedings of 6th SIAM Conference on Data Mining, 2006, pp. 484-488.

Definition at line 108 of file CCLSVClustering.cpp.

References damina::SVClustering::getKernelWidth(), damina::SVClustering::getSphereRadius(), and zeta.

Referenced by experimentalSeparateClusters(), and separateClusters().

                                            {
                double R = getSphereRadius();
                double q = getKernelWidth();
                
                //double sqrt_1_R = sqrt(1 - R*R);
                double sqrt_1_R = sqrt(1 - R);
                double ln = log(sqrt_1_R);

                this->zeta = sqrt(-(ln/q));
                //this->zeta = -(ln/q);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

void damina::CCLSVClustering::clusterize

(

)

[virtual]

Run the clustering process.

In this case it runs the Step 2 of Support Vector Clustering, called "Cluster Labeling" by its authors.

The implementation reflects the solution proposed in

S. Lee and K. M. Daniels, "Cone Cluster Labeling for Support Vector Clustering," in Proceedings of 6th SIAM Conference on Data Mining, 2006, pp. 484-488.

S. Lee and K. M. Daniels, "Gaussian Kernel Width Selection and Fast Cluster Labeling for Support Vector Clustering," Department of Computer Science, University of Massachussets Lowell 2005.

namely, Cone Cluster Labeling

Reimplemented from damina::SVClustering.

Definition at line 92 of file CCLSVClustering.cpp.

References separateClusters().

                                         {
                this->separateClusters();
                //this->experimentalSeparateClusters();
        }

Here is the call graph for this function:

void damina::CCLSVClustering::clusterizeBSVs

(

)

[inline, private]

Definition at line 81 of file CCLSVClustering.h.

{};

void damina::CCLSVClustering::experimentalSeparateClusters

(

)

[protected, virtual]

Definition at line 277 of file CCLSVClustering.cpp.

References damina::SVClustering::beta(), damina::SVClustering::C_estimation, damina::EuclideanDistance::calculateDistance(), calculateZeta(), damina::SVClustering::eucDist, damina::SVClustering::getKernelWidth(), damina::OneClassSVM::getModel(), damina::SVClustering::getParameters(), damina::OneClassSVM::getProblem(), damina::SVClustering::getSoftConstraint(), damina::SVClustering::labels, damina::SVClustering::trainer, damina::SVClustering::usingSpecialClusteringPolicyForBSV(), and zeta.

                                                           {
                // compute Zeta
                calculateZeta();

                double ker_zeta = exp(-1 * getKernelWidth() * zeta);
                
                int i,j;                //      to run over the SVs 
                        
                int nSV = this->trainer->getModel()->l - this->trainer->getModel()->lbounded;
                int *SV_index = this->trainer->getModel()->SV_index;
                
                
                /*      original dataset */
                struct svm_node **x = this->trainer->getProblem()->x;
                double dist;
                
                
                /* arithmetic mean of all betas */
                double betas_average = 0;
                double beta_max = -1;
                
                /*      adj matrix only for real SVs */
                UndirectedGraph adj(nSV);
                for (i = 0; i < nSV; i++) {
                        betas_average += beta(i, false);                                                        //      sum all betas
                        if (beta(i, false) > beta_max) beta_max = beta(i, false);       //      max beta

                        for (j = 0; j < nSV; j++) {
                                
                                //      trivial: each node is connected to itself
                                if (i == j) {
                                        add_edge(i, j, adj);
                                        continue;
                                }
                                
                                // avoid to set the same edge more than once
                                if (edge(i, j, adj).second) continue;
                                
                                
                                //dist = eucDist->calculateDistance(x[SV_index[i]], x[SV_index[j]]);
                                dist = 2 - 2 * kernelfunction(x[SV_index[i]], x[SV_index[j]], *(getParameters()));

                                //      zeta is the radius of the hyperspheres in data space centered in the SVs
                                //      (all hyperspheres have the same radius)
                                //      Two SVs are connected if their hyperspheres overlap, i.e. if the 
                                //      distance between two SVs are at most 2*zeta (overlap in 1 point)
                                if (dist <=  2 * ker_zeta) {              
                                        add_edge(i, j, adj);
                                        add_edge(j, i, adj);
                                }
                                else {
                                        remove_edge(i, j, adj);
                                        remove_edge(j, i, adj);
                                }
                        }
                }
                betas_average = betas_average / nSV;    //      divide the sum of all betas by numer of betas => arithmetic mean
                
                
                // clustering SVs finding connected components of the adj matrix just built
                std::vector<int> svLabels(nSV);
                connected_components(adj, &svLabels[0]);
                
                
                // total points
                int N = this->trainer->getProblem()->l;
                
                // total labels
                labels.resize(N);

                double mindist;
                int minsvindex;
                
                C_estimation = 10.0 * getSoftConstraint() / N;  

                // clustering points other than SVs
                // for each point in the input data set 
                for (i = 0; i < N; i++) {
                        mindist = MAXFLOAT; 
                        minsvindex = -1;
                        for (j = 0; j < nSV; j++) {     // we find the nearest SV
                        
                                if (i == SV_index[j]) { //      trivial if the point is the current SV
                                        minsvindex = j;
                                        break;
                                }
                                
                                //dist = eucDist->calculateDistance(x[SV_index[j]], x[i]);

                                dist = 2 - 2 * kernelfunction(x[SV_index[j]], x[i], *(getParameters()));

                                //if (dist < mindist) { //      if the distance between a point and an SV is less or equal than zeta
                                                                                //      and it is also less than the last distance found 
                                if ((dist < mindist) && (dist <= ker_zeta)) {
                                        mindist = dist;
                                        minsvindex = j;
                                }  
                        }

                        //labels[i] = svLabels[minsvindex];
                        if (minsvindex == -1) {
                                mindist = MAXFLOAT; 
                                minsvindex = -1;
                                for (j = 0; j < N; j++) {
                                        if (i != j) {
                                                dist = 2 - 2 * kernelfunction(x[i], x[j], *(getParameters()));
                                                //dist = eucDist->calculateDistance(x[j], x[i]);
                                                if (dist < mindist) {
                                                        mindist = dist;
                                                        minsvindex = j;
                                                }
                                        }       
                                }
                                labels[i] = labels[minsvindex];
                        }
                        else {
                                labels[i] = svLabels[minsvindex];
                        }
                }

                if (usingSpecialClusteringPolicyForBSV()) {
                                // try to cluster BSV points
                                int nBSV = this->trainer->getModel()->lbounded;
                                int *BSV_index = this->trainer->getModel()->BSV_index;
                                
                                for (i = 0; i < nBSV; i++) {
                                        mindist = MAXFLOAT; 
                                        minsvindex = 0;
                                        for (j = 0; j < N; j++) {
                                                if (j == BSV_index[i]) continue;        //      ignore if the point is the current BSV
                                                if (beta(j, true) == 1) continue;       //      ignore all BSVs
                                                dist = eucDist->calculateDistance(x[BSV_index[i]],x[j]);
                                                if (dist < mindist) {
                                                        mindist = dist;
                                                        minsvindex = j;
                                                }
                                        }
                                        labels[BSV_index[i]] = labels[minsvindex];
                                }
                }
        
        }

Here is the call graph for this function:

std::vector< int > & damina::SVClustering::getClustersAssignment

(

)

[virtual, inherited]

Returns the clustering assignments.

In the i-th position you can find the cluster wich contains the i-th input data point

Returns:

A vector encapsulating the clustering assignments

Definition at line 387 of file SVClustering.cpp.

References damina::SVClustering::labels.

Referenced by countRightAndWrongClassificationsPerClass(), and printAllPoints().

                                                            {
                return labels;
        }

Here is the caller graph for this function:

int damina::SVClustering::getKernelType

(

)

[virtual, inherited]

Returns the current kernel type.

Returns:

The kernel type

Definition at line 326 of file SVClustering.cpp.

References damina::AbstractSVM::getKernel(), and damina::SVClustering::trainer.

                                        {
                return this->trainer->getKernel();
        }

Here is the call graph for this function:

double damina::SVClustering::getKernelWidth

(

)

[virtual, inherited]

Returns the current value of the Kernel Width.

Returns:

The current value of the Gaussian Kernel Width

Definition at line 302 of file SVClustering.cpp.

References damina::AbstractSVM::getKernelWidth(), and damina::SVClustering::trainer.

Referenced by calculateZeta(), and experimentalSeparateClusters().

                                            {
                return this->trainer->getKernelWidth();
        }

Here is the call graph for this function:

Here is the caller graph for this function:

struct svm_model * damina::SVClustering::getModel

(

)

[read, virtual, inherited]

Returns the trained model.

Returns:

The trained model, with objective function, lagrangians, etc.

Definition at line 241 of file SVClustering.cpp.

References damina::OneClassSVM::getModel(), and damina::SVClustering::trainer.

Referenced by damina::GKWGenerator::getNextKernelWidthValue().

                                                 {
                return this->trainer->getModel();
        }

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned long int damina::SVClustering::getNumberOfClusters

(

)

[virtual, inherited]

Returns the number of clusters found.

Returns:

An integer value which is the number of clusters found

Definition at line 434 of file SVClustering.cpp.

References damina::SVClustering::labels, damina::SVClustering::numberOfClusters, and damina::SVClustering::pointPerCluster.

                                                            {
                
                if (numberOfClusters > -1)
                        return numberOfClusters;
                
                // calculating points per cluster and number of clusters detected
                
                // theoretically impossible
                // here to detect some programming errors
                if (labels.size() == 0) {
                        this->numberOfClusters = 0;
                        return numberOfClusters;
                }
                
                
                std::vector<int>::size_type idx;
                this->pointPerCluster.push_back(0);
                this->numberOfClusters = 1;
        for (idx = 0; idx < labels.size(); idx++) {
                        if ((int)(pointPerCluster.size() - 1) < labels[idx]) {
                        this->numberOfClusters++;
                        this->pointPerCluster.push_back(1);
                }
                else {
                        this->pointPerCluster[labels[idx]]++;
                }
        }

                return numberOfClusters;
        }

unsigned long int damina::SVClustering::getNumberOfNonSingletonClusters

(

)

[virtual, inherited]

Returns the number of clusters containing more than one point.

Returns:

An integer value which is the number of non-singleton clusters

Definition at line 470 of file SVClustering.cpp.

References damina::SVClustering::getNumberOfValidClusters().

                                                                        {
                return getNumberOfValidClusters(2);
        }

Here is the call graph for this function:

unsigned long int damina::SVClustering::getNumberOfValidClusters

(

unsigned long int

threshold

)

[virtual, inherited]

Returns the number of clusters with a number of elements greater than or equal to a certain threshold.

Parameters:

threshold

An integer value representing the minimum number of elements for a valid cluster

Returns:

An integer value which is the number of clusters requested

Definition at line 480 of file SVClustering.cpp.

References damina::SVClustering::getPointPerCluster(), and damina::SVClustering::pointPerCluster.

Referenced by damina::SVClustering::getNumberOfNonSingletonClusters().

                                                                                            {
                getPointPerCluster();
                unsigned long int counter = 0;
                for (unsigned long int i = 0; i < pointPerCluster.size(); i++) {
                        if (pointPerCluster[i] >= threshold) {
                                counter++;