added Support and supportVectors in SVC members. +coverage improvement

Author: pa-m

cluster/distance_test.go

@@ -0,0 +1,25 @@
+package cluster
+
+import (
+	"gonum.org/v1/gonum/mat"
+	"math"
+	"testing"
+)
+
+func TestMinkowskiDistanceP(t *testing.T) {
+	a := mat.NewVecDense(2, []float64{0, 0})
+	b := mat.NewVecDense(2, []float64{1, 2})
+	if MinkowskiDistanceP(a, a, 2) != 0 {
+		t.Fail()
+	}
+	if MinkowskiDistanceP(b, b, 2) != 0 {
+		t.Fail()
+	}
+	if math.Abs(5-MinkowskiDistanceP(a, b, 2)) > 1e-9 {
+		t.Fail()
+	}
+	actual := MinkowskiDistanceP(a, b, math.Inf(1))
+	if math.Abs(2-actual) > 1e-9 {
+		t.Errorf("got %g", actual)
+	}
+}

metrics/regression_test.go

@@ -60,7 +60,8 @@ func ExampleR2Score() {
 
 	yTrue = mat.NewDense(3, 1, []float64{1, 2, 3})
 	yPred = mat.NewDense(3, 1, []float64{3, 2, 1})
-	fmt.Printf("%g\n", R2Score(yTrue, yPred, nil, "").At(0, 0))
+	sampleWeight := mat.NewDense(3, 1, []float64{1, 1, 1})
+	fmt.Printf("%g\n", R2Score(yTrue, yPred, sampleWeight, "").At(0, 0))
 	// Output:
 	// 0.949
 	// 0.938

neighbors/kdtree.go

@@ -23,6 +23,9 @@ func NewRectangle(Maxes, Mins []float64) *Rectangle {
 func (r *Rectangle) String() string {
 	s := "<Rectangle "
 	for axis := 0; axis < len(r.Maxes); axis++ {
+		if axis > 0 {
+			s += ", "
+		}
 		s += fmt.Sprint(r.Mins[axis], r.Maxes[axis])
 	}
 	s += ">"

neighbors/kdtree_test.go

@@ -5,8 +5,27 @@ import (
 	"math"
 
 	"gonum.org/v1/gonum/mat"
+	"testing"
 )
 
+func TestRectangle(t *testing.T) {
+	R := NewRectangle([]float64{3, 4}, []float64{1, 2})
+	expected := "<Rectangle 1 3, 2 4>"
+	actual := R.String()
+	if expected != actual {
+		t.Errorf("expected %s, got %s", expected, actual)
+	}
+	if R.Volume() != 4. {
+		t.Errorf("wrong volume")
+	}
+	if math.Abs(2.237-R.MinDistancePoint([]float64{0, 0}, 2)) > 1.e-3 {
+		t.Error("err MinDistancePoint")
+	}
+	if math.Abs(5-R.MaxDistancePoint([]float64{0, 0}, 2)) > 1.e-3 {
+		t.Error("err MaxDistancePoint")
+	}
+}
+
 func ExampleKDTree() {
 	// v https://github.com/scipy/scipy/blob/v1.1.0/scipy/spatial/kdtree.py
 	X := mat.NewDense(30, 2, nil)

neighbors/unsupervised_test.go

@@ -86,3 +86,19 @@ func ExampleNearestNeighbors_Tree() {
 	// [1  5  8]
 	// [1  6  8]
 }
+
+func ExampleNearestNeighbors_RadiusNeighbors() {
+	// adapted example from http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.RadiusNeighborsRegressor.html#sklearn.neighbors.RadiusNeighborsRegressor
+	samples := mat.NewDense(3, 3, []float64{0, 0, 0, 0, .5, 0, 1, 1, .5})
+	neigh := NewNearestNeighbors()
+	neigh.Fit(samples)
+	distances, indices := neigh.RadiusNeighbors(mat.NewDense(1, 3, []float64{1, 1, 1}), 1.6)
+	fmt.Println(distances[0])
+	fmt.Println(indices[0])
+	// unlike the python example, distances are sorted by increasing distances
+
+	// Output:
+	// [0.5 1.5]
+	// [2 1]
+
+}

svm/svm.go

@@ -24,6 +24,7 @@ type Model struct {
 	B              float64
 	Alphas         []float64
 	W              []float64
+	Support        []int
 }
 
 // %svmTrain Trains an SVM classifier using a simplified version of the SMO
@@ -160,12 +161,12 @@ func svmTrain(X *mat.Dense, Y []float64, C float64, KernelFunction func(X1, X2 [
 		B:              b,
 		Alphas:         make([]float64, len(idx)),
 		W:              make([]float64, n, n),
+		Support:        idx,
 	}
 	for ii, i := range idx {
 		model.X.SetRow(ii, X.RawRowView(i))
 		model.Y[ii] = Y[i]
 		model.Alphas[ii] = alphas[i]
-
 	}
 	for j := 0; j < n; j++ {
 		for _, i := range idx {
@@ -196,7 +197,6 @@ func svmPredict(model *Model, X *mat.Dense) (pred []float64) {
 		}
 	}
 	return
-
 }
 
 // Kernel is the interface for kernels
@@ -252,18 +252,20 @@ func (kdata SigmoidKernel) Func(a, b []float64) (sumprod float64) {
 
 // SVC struct
 type SVC struct {
-	C           float64
-	Kernel      interface{}
-	Degree      float64
-	Gamma       float64
-	Coef0       float64
-	Shrinking   bool
-	Probability bool
-	Tol         float64
-	CacheSize   uint
-	ClassWeight []float64
-	MaxIter     int
-	Model       []*Model
+	C              float64
+	Kernel         interface{}
+	Degree         float64
+	Gamma          float64
+	Coef0          float64
+	Shrinking      bool
+	Probability    bool
+	Tol            float64
+	CacheSize      uint
+	ClassWeight    []float64
+	MaxIter        int
+	Model          []*Model
+	Support        [][]int
+	SupportVectors [][][]float64
 }
 
 // NewSVC ...
@@ -310,12 +312,19 @@ func (m *SVC) Fit(X, Y *mat.Dense) base.Transformer {
 	if m.MaxIter <= 0 {
 		m.MaxIter = math.MaxInt32
 	}
+	m.Support = make([][]int, Noutputs)
+	m.SupportVectors = make([][][]float64, Noutputs)
 	base.Parallelize(-1, Noutputs, func(th, start, end int) {
 		y := make([]float64, NSamples)
 		for output := start; output < end; output++ {
 			mat.Col(y, output, Y)
 			m.Model[output] = svmTrain(X, y, m.C, K, m.Tol, m.MaxIter, m.CacheSize)
-
+			model := m.Model[output]
+			m.Support[output] = model.Support
+			m.SupportVectors[output] = make([][]float64, len(model.Support))
+			for i := range model.Support {
+				m.SupportVectors[output][i] = model.X.RawRowView(i)
+			}
 		}
 	})
 	return m

svm/svm_test.go

@@ -32,26 +32,26 @@ func ExampleSVC() {
 	X1 := X
 	Y1, _ := yscaler.FitTransform(Y, nil)
 	plots := [][]*plot.Plot{make([]*plot.Plot, 0, 4)}
+	var clf *SVC
 	for _, kernel := range []string{
 		"linear",
 		"poly",
 		"rbf",
 	} {
-		m := NewSVC()
-		m.Kernel = kernel
-		m.C = 1.
-		m.Gamma = 2.
-		m.Tol = 1.e-3
-		m.MaxIter = 20
-		m.Fit(X1, Y1)
+		clf = NewSVC()
+		clf.Kernel = kernel
+		//clf.C = 1.
+		clf.Gamma = 2.
+		//clf.Tol = 1.e-3
+		clf.MaxIter = 20
+		clf.Fit(X1, Y1)
 		Ypred := mat.NewDense(16, 1, nil)
-		m.Predict(X, Ypred)
+		clf.Predict(X, Ypred)
 		fmt.Printf("%s kernel, accuracy:%.3f\n", kernel, metrics.AccuracyScore(Y, Ypred, true, nil))
 		// Put the result into a color plot
 		if *visualDebug {
 			// Plot the decision boundary. For that, we will assign a color to each point in the mesh [x_min, x_max]x[y_min, y_max].
 			var xmin, xmax = -3., 3.
-
 			var ymin, ymax = -3., 3.
 			h := (ymax - ymin) / 100
 
@@ -82,7 +82,7 @@ func ExampleSVC() {
 			var xx, yy = npmeshgrid(nparange(xmin, xmax, h), nparange(ymin, ymax, h))
 			Xgrid := npc(xx, yy)
 			Z := &mat.Dense{}
-			m.Predict(Xgrid, Z)
+			clf.Predict(Xgrid, Z)
 			plt, _ := plot.New()
 			xys := func(X, Y mat.Matrix, cls int) (xy plotter.XYs) {
 				imax, _ := Y.Dims()