Created the entity of an Estimator - object allowing to find the optimal number of clusters. The solution is bases on the gap statistic method proposed by Tibshirani et al.

Author: mpraski

clusters.go

@@ -1,8 +1,6 @@
 package clusters
 
 import (
-	"math"
-
 	"gonum.org/v1/gonum/floats"
 )
 
@@ -30,11 +28,10 @@ type TestResult struct {
 	clusters, expected int
 }
 
-/* Clusterer denotes a operations of learning and testing
+/* Clusterer denotes the operation of learning
  * common for both Hard and Soft clusterers */
 type Clusterer interface {
 	Learn([][]float64) error
-	Test([][]float64, ...interface{}) (*TestResult, error)
 }
 
 /* HardClusterer defines a set of operations for hard clustering algorithms */
@@ -84,12 +81,19 @@ type SoftClusterer interface {
 	Clusterer
 }
 
+type Estimator interface {
+
+	/* Estimates the numer of clusters */
+	Estimate([][]float64) (int, error)
+}
+
 var (
 	EuclideanDistance = func(a, b []float64) float64 {
 		return floats.Distance(a, b, 2)
 	}
 
 	EuclideanDistanceSquared = func(a, b []float64) float64 {
-		return math.Pow(floats.Distance(a, b, 2), 2)
+		t := floats.Distance(a, b, 2)
+		return t * t
 	}
 )

dbscan.go

@@ -102,14 +102,6 @@ func (c *dbscanClusterer) Learn(data [][]float64) error {
 	return nil
 }
 
-func (c *dbscanClusterer) Test(data [][]float64, args ...interface{}) (*TestResult, error) {
-	if len(data) == 0 {
-		return nil, ErrEmptySet
-	}
-
-	return nil, nil
-}
-
 func (c *dbscanClusterer) Sizes() []int {
 	c.mu.RLock()
 	defer c.mu.RUnlock()

errors.go

@@ -3,13 +3,14 @@ package clusters
 import "errors"
 
 var (
-	ErrEmptySet       = errors.New("Empty training set")
-	ErrNotTrained     = errors.New("You need to train the algorithm first")
-	ErrZeroIterations = errors.New("Number of iterations cannot be less than 1")
-	ErrOneCluster     = errors.New("Number of clusters cannot be less than 2")
-	ErrZeroEpsilon    = errors.New("Epsilon cannot be 0")
-	ErrZeroMinpts     = errors.New("MinPts cannot be 0")
-	ErrZeroWorkers    = errors.New("Number of workers cannot be less than 0")
-	ErrZeroXi         = errors.New("Xi cannot be 0")
-	ErrInvalidRange   = errors.New("Range is invalid")
+	ErrEmptySet            = errors.New("Empty training set")
+	ErrNotTrained          = errors.New("You need to train the algorithm first")
+	ErrZeroIterations      = errors.New("Number of iterations cannot be less than 1")
+	ErrOneCluster          = errors.New("Number of clusters cannot be less than 2")
+	ErrZeroEpsilon         = errors.New("Epsilon cannot be 0")
+	ErrZeroMinpts          = errors.New("MinPts cannot be 0")
+	ErrZeroWorkers         = errors.New("Number of workers cannot be less than 0")
+	ErrZeroXi              = errors.New("Xi cannot be 0")
+	ErrInvalidRange        = errors.New("Range is invalid")
+	ErrTestingNotSupported = errors.New("Testing is not supported for this algorithm")
 )

kmeans.go

@@ -1,7 +1,6 @@
 package clusters
 
 import (
-	"errors"
 	"math"
 	"math/rand"
 	"sync"
@@ -109,52 +108,6 @@ func (c *kmeansClusterer) Learn(data [][]float64) error {
 	return nil
 }
 
-func (c *kmeansClusterer) Test(data [][]float64, args ...interface{}) (*TestResult, error) {
-	if len(data) == 0 {
-		return nil, ErrEmptySet
-	}
-
-	clusters, ok := args[0].(int)
-	if !ok {
-		return nil, errors.New("Argument #0 is invalid")
-	}
-
-	var (
-		size   = len(data)
-		bounds = bounds(data)
-		wks    = make([]float64, clusters)
-		wkbs   = make([]float64, clusters)
-		sk     = make([]float64, clusters)
-		one    = make([]float64, clusters)
-		bwkbs  = make([]float64, clusters)
-	)
-
-	for i := 0; i < clusters; i++ {
-		c.Learn(data)
-
-		wks[i] = math.Log(wk(c.d, c.m, c.a))
-
-		for j := 0; j < clusters; j++ {
-			c.Learn(c.buildRandomizedSet(size, bounds))
-
-			bwkbs[j] = math.Log(wk(c.d, c.m, c.a))
-			one[j] = 1
-		}
-
-		wkbs[i] = floats.Sum(bwkbs) / float64(clusters)
-
-		floats.Scale(wkbs[i], one)
-		floats.Sub(bwkbs, one)
-		floats.Mul(bwkbs, bwkbs)
-
-		sk[i] = math.Sqrt(floats.Sum(bwkbs) / float64(clusters))
-	}
-
-	floats.Scale(math.Sqrt(1+(1/float64(clusters))), sk)
-
-	return nil, nil
-}
-
 func (c *kmeansClusterer) Sizes() []int {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
@@ -371,20 +324,3 @@ func (c *kmeansClusterer) check() {
 
 	c.oldchanges = c.changes
 }
-
-func (c *kmeansClusterer) buildRandomizedSet(size int, bounds []*[2]float64) [][]float64 {
-	var (
-		l = len(bounds)
-		r = make([][]float64, size)
-	)
-
-	for i := 0; i < size; i++ {
-		r[i] = make([]float64, l)
-
-		for j := 0; j < l; j++ {
-			r[i][j] = uniform(bounds[j])
-		}
-	}
-
-	return r
-}