[*] NClasses -> NRawOutputGroups

Author: dmitryikh

doc.go

@@ -61,7 +61,7 @@ predict_breast_cancer_model.go:
 		}
 		fmt.Printf("Name: %s\n", model.Name())
 		fmt.Printf("NFeatures: %d\n", model.NFeatures())
-		fmt.Printf("NClasses: %d\n", model.NClasses())
+		fmt.Printf("NRawOutputGroups: %d\n", model.NRawOutputGroups())
 		fmt.Printf("NEstimators: %d\n", model.NEstimators())
 
 		// loading true predictions as DenseMat
@@ -71,7 +71,7 @@ predict_breast_cancer_model.go:
 		}
 
 		// preallocate slice to store model predictions
-		predictions := make([]float64, test.Rows*model.NClasses())
+		predictions := make([]float64, test.Rows*model.NRawOutputGroups())
 		// do predictions
 		model.PredictDense(test.Values, test.Rows, test.Cols, predictions, 0, 1)
 		// compare results
@@ -86,7 +86,7 @@ Output:
 
 	Name: lightgbm.gbdt
 	NFeatures: 30
-	NClasses: 1
+	NRawOutputGroups: 1
 	NEstimators: 30
 	Predictions the same!
 
@@ -146,7 +146,7 @@ predict_iris_model.go:
 		}
 		fmt.Printf("Name: %s\n", model.Name())
 		fmt.Printf("NFeatures: %d\n", model.NFeatures())
-		fmt.Printf("NClasses: %d\n", model.NClasses())
+		fmt.Printf("NRawOutputGroups: %d\n", model.NRawOutputGroups())
 		fmt.Printf("NEstimators: %d\n", model.NEstimators())
 
 		// loading true predictions as DenseMat
@@ -156,7 +156,7 @@ predict_iris_model.go:
 		}
 
 		// preallocate slice to store model predictions
-		predictions := make([]float64, csr.Rows()*model.NClasses())
+		predictions := make([]float64, csr.Rows()*model.NRawOutputGroups())
 		// do predictions
 		model.PredictCSR(csr.RowHeaders, csr.ColIndexes, csr.Values, predictions, 0, 1)
 		// compare results
@@ -177,7 +177,7 @@ Output:
 
 	Name: xgboost.gbtree
 	NFeatures: 4
-	NClasses: 3
+	NRawOutputGroups: 3
 	NEstimators: 5
 	Predictions the same! (mismatch = 0)
 

leaves.go

@@ -12,7 +12,7 @@ const BatchSize = 16
 
 type ensembleBaseInterface interface {
 	NEstimators() int
-	NClasses() int
+	NRawOutputGroups() int
 	NFeatures() int
 	Name() string
 	adjustNEstimators(nEstimators int) int
@@ -32,7 +32,7 @@ type Ensemble struct {
 // function transformation and etc)
 // NOTE: for multiclass prediction use Predict
 func (e *Ensemble) PredictSingle(fvals []float64, nEstimators int) float64 {
-	if e.NClasses() != 1 {
+	if e.NRawOutputGroups() != 1 {
 		return 0.0
 	}
 	if e.NFeatures() > len(fvals) {
@@ -51,8 +51,8 @@ func (e *Ensemble) PredictSingle(fvals []float64, nEstimators int) float64 {
 // NOTE: for single class predictions one can use simplified function PredictSingle
 func (e *Ensemble) Predict(fvals []float64, nEstimators int, predictions []float64) error {
 	nRows := 1
-	if len(predictions) < e.NClasses()*nRows {
-		return fmt.Errorf("predictions slice too short (should be at least %d)", e.NClasses()*nRows)
+	if len(predictions) < e.NRawOutputGroups()*nRows {
+		return fmt.Errorf("predictions slice too short (should be at least %d)", e.NRawOutputGroups()*nRows)
 	}
 	if e.NFeatures() > len(fvals) {
 		return fmt.Errorf("incorrect number of features (%d)", len(fvals))
@@ -72,8 +72,8 @@ func (e *Ensemble) Predict(fvals []float64, nEstimators int, predictions []float
 // Note, `predictions` slice should be properly allocated on call side
 func (e *Ensemble) PredictCSR(indptr []int, cols []int, vals []float64, predictions []float64, nEstimators int, nThreads int) error {
 	nRows := len(indptr) - 1
-	if len(predictions) < e.NClasses()*nRows {
-		return fmt.Errorf("predictions slice too short (should be at least %d)", e.NClasses()*nRows)
+	if len(predictions) < e.NRawOutputGroups()*nRows {
+		return fmt.Errorf("predictions slice too short (should be at least %d)", e.NRawOutputGroups()*nRows)
 	}
 	nEstimators = e.adjustNEstimators(nEstimators)
 	if nRows <= BatchSize || nThreads == 0 || nThreads == 1 {
@@ -136,7 +136,7 @@ func (e *Ensemble) predictCSRInner(
 				fvals[cols[j]] = vals[j]
 			}
 		}
-		e.predictInner(fvals, nEstimators, predictions, i*e.NClasses())
+		e.predictInner(fvals, nEstimators, predictions, i*e.NRawOutputGroups())
 		e.resetFVals(fvals)
 	}
 }
@@ -156,8 +156,8 @@ func (e *Ensemble) PredictDense(
 	nThreads int,
 ) error {
 	nRows := nrows
-	if len(predictions) < e.NClasses()*nRows {
-		return fmt.Errorf("predictions slice too short (should be at least %d)", e.NClasses()*nRows)
+	if len(predictions) < e.NRawOutputGroups()*nRows {
+		return fmt.Errorf("predictions slice too short (should be at least %d)", e.NRawOutputGroups()*nRows)
 	}
 	if ncols == 0 || e.NFeatures() > ncols {
 		return fmt.Errorf("incorrect number of columns")
@@ -166,7 +166,7 @@ func (e *Ensemble) PredictDense(
 	if nRows <= BatchSize || nThreads == 0 || nThreads == 1 {
 		// single thread calculations
 		for i := 0; i < nRows; i++ {
-			e.predictInner(vals[i*ncols:(i+1)*ncols], nEstimators, predictions, i*e.NClasses())
+			e.predictInner(vals[i*ncols:(i+1)*ncols], nEstimators, predictions, i*e.NRawOutputGroups())
 		}
 		return nil
 	}
@@ -190,7 +190,7 @@ func (e *Ensemble) PredictDense(
 					endIndex = nRows
 				}
 				for i := startIndex; i < endIndex; i++ {
-					e.predictInner(vals[i*int(ncols):(i+1)*int(ncols)], nEstimators, predictions, i*e.NClasses())
+					e.predictInner(vals[i*int(ncols):(i+1)*int(ncols)], nEstimators, predictions, i*e.NRawOutputGroups())
 				}
 			}
 		}()
@@ -205,14 +205,16 @@ func (e *Ensemble) PredictDense(
 	return nil
 }
 
-// NEstimators returns number of estimators (trees) in ensemble (per class)
+// NEstimators returns number of estimators (trees) in ensemble (per group)
 func (e *Ensemble) NEstimators() int {
 	return e.ensembleBaseInterface.NEstimators()
 }
 
-// NClasses returns number of classes to predict
-func (e *Ensemble) NClasses() int {
-	return e.ensembleBaseInterface.NClasses()
+// NRawOutputGroups returns number of groups (numbers) in every object
+// predictions. For example binary logistic model will give 1, but 4-class
+// prediction model will give 4 numbers per object
+func (e *Ensemble) NRawOutputGroups() int {
+	return e.ensembleBaseInterface.NRawOutputGroups()
 }
 
 // NFeatures returns number of features in the model

leaves_test.go

@@ -459,8 +459,8 @@ func InnerTestLGMulticlass(t *testing.T, nThreads int) {
 	if model.NEstimators() != 10 {
 		t.Fatalf("expected 10 trees (got %d)", model.NEstimators())
 	}
-	if model.NClasses() != 5 {
-		t.Fatalf("expected 5 classes (got %d)", model.NClasses())
+	if model.NRawOutputGroups() != 5 {
+		t.Fatalf("expected 5 classes (got %d)", model.NRawOutputGroups())
 	}
 
 	// loading true predictions as DenseMat
@@ -470,7 +470,7 @@ func InnerTestLGMulticlass(t *testing.T, nThreads int) {
 	}
 
 	// do predictions
-	predictions := make([]float64, dense.Rows*model.NClasses())
+	predictions := make([]float64, dense.Rows*model.NRawOutputGroups())
 	model.PredictDense(dense.Values, dense.Rows, dense.Cols, predictions, 0, nThreads)
 	// compare results
 	const tolerance = 1e-7
@@ -481,12 +481,12 @@ func InnerTestLGMulticlass(t *testing.T, nThreads int) {
 	// check Predict
 	singleIdx := 200
 	fvals := dense.Values[singleIdx*dense.Cols : (singleIdx+1)*dense.Cols]
-	predictions = make([]float64, model.NClasses())
+	predictions = make([]float64, model.NRawOutputGroups())
 	err = model.Predict(fvals, 0, predictions)
 	if err != nil {
 		t.Errorf("error while call model.Predict: %s", err.Error())
 	}
-	if err := util.AlmostEqualFloat64Slices(truePredictions.Values[singleIdx*model.NClasses():(singleIdx+1)*model.NClasses()], predictions, tolerance); err != nil {
+	if err := util.AlmostEqualFloat64Slices(truePredictions.Values[singleIdx*model.NRawOutputGroups():(singleIdx+1)*model.NRawOutputGroups()], predictions, tolerance); err != nil {
 		t.Errorf("different Predict prediction: %s", err.Error())
 	}
 }
@@ -531,7 +531,7 @@ func InnerTestXGDermatology(t *testing.T, nThreads int) {
 	}
 
 	// do predictions
-	predictions := make([]float64, csr.Rows()*model.NClasses())
+	predictions := make([]float64, csr.Rows()*model.NRawOutputGroups())
 	model.PredictCSR(csr.RowHeaders, csr.ColIndexes, csr.Values, predictions, 0, nThreads)
 	// compare results
 	const tolerance = 1e-6
@@ -563,7 +563,7 @@ func TestSKGradientBoostingClassifier(t *testing.T) {
 	}
 
 	// do predictions
-	predictions := make([]float64, csr.Rows()*model.NClasses())
+	predictions := make([]float64, csr.Rows()*model.NRawOutputGroups())
 	model.PredictCSR(csr.RowHeaders, csr.ColIndexes, csr.Values, predictions, 0, 1)
 	// compare results
 	const tolerance = 1e-6
@@ -597,7 +597,7 @@ func TestSKIris(t *testing.T) {
 	}
 
 	// do predictions
-	predictions := make([]float64, csr.Rows()*model.NClasses())
+	predictions := make([]float64, csr.Rows()*model.NRawOutputGroups())
 	model.PredictCSR(csr.RowHeaders, csr.ColIndexes, csr.Values, predictions, 0, 1)
 	// compare results
 	const tolerance = 1e-6
@@ -639,7 +639,7 @@ func TestLGRandomForestIris(t *testing.T) {
 	}
 
 	// do predictions
-	predictions := make([]float64, csr.Rows()*model.NClasses())
+	predictions := make([]float64, csr.Rows()*model.NRawOutputGroups())
 	model.PredictCSR(csr.RowHeaders, csr.ColIndexes, csr.Values, predictions, 0, 1)
 	// compare results
 	const tolerance = 1e-6
@@ -714,7 +714,7 @@ func TestLGDARTBreastCancer(t *testing.T) {
 	}
 
 	// do predictions
-	predictions := make([]float64, test.Rows*model.NClasses())
+	predictions := make([]float64, test.Rows*model.NRawOutputGroups())
 	err = model.PredictDense(test.Values, test.Rows, test.Cols, predictions, 0, 1)
 	if err != nil {
 		t.Fatal(err)
@@ -753,7 +753,7 @@ func TestLGKDDCup99(t *testing.T) {
 	}
 
 	// do predictions
-	predictions := make([]float64, test.Rows*model.NClasses())
+	predictions := make([]float64, test.Rows*model.NRawOutputGroups())
 	err = model.PredictDense(test.Values, test.Rows, test.Cols, predictions, 0, 1)
 	if err != nil {
 		t.Fatal(err)
@@ -790,7 +790,7 @@ func InnerBenchmarkLGKDDCup99(b *testing.B, nThreads int) {
 
 	// do benchmark
 	b.ResetTimer()
-	predictions := make([]float64, test.Rows*model.NClasses())
+	predictions := make([]float64, test.Rows*model.NRawOutputGroups())
 	for i := 0; i < b.N; i++ {
 		model.PredictDense(test.Values, test.Rows, test.Cols, predictions, 0, nThreads)
 	}
@@ -826,7 +826,7 @@ func TestLGJsonBreastCancer(t *testing.T) {
 	}
 
 	// do predictions
-	predictions := make([]float64, test.Rows*model.NClasses())
+	predictions := make([]float64, test.Rows*model.NRawOutputGroups())
 	err = model.PredictDense(test.Values, test.Rows, test.Cols, predictions, 0, 1)
 	if err != nil {
 		t.Fatal(err)

lgensemble.go

@@ -6,9 +6,9 @@ import (
 
 // lgEnsemble is LightGBM model (ensemble of trees)
 type lgEnsemble struct {
-	Trees         []lgTree
-	MaxFeatureIdx int
-	nClasses      int
+	Trees            []lgTree
+	MaxFeatureIdx    int
+	nRawOutputGroups int
 	// lgEnsemble suits for different models from different packages (ex., LightGBM gbrt & sklearn gbrt)
 	// name contains the origin of the model
 	name string
@@ -19,11 +19,11 @@ type lgEnsemble struct {
 }
 
 func (e *lgEnsemble) NEstimators() int {
-	return len(e.Trees) / e.nClasses
+	return len(e.Trees) / e.nRawOutputGroups
 }
 
-func (e *lgEnsemble) NClasses() int {
-	return e.nClasses
+func (e *lgEnsemble) NRawOutputGroups() int {
+	return e.nRawOutputGroups
 }
 
 func (e *lgEnsemble) NFeatures() int {
@@ -38,16 +38,16 @@ func (e *lgEnsemble) Name() string {
 }
 
 func (e *lgEnsemble) predictInner(fvals []float64, nEstimators int, predictions []float64, startIndex int) {
-	for k := 0; k < e.nClasses; k++ {
+	for k := 0; k < e.nRawOutputGroups; k++ {
 		predictions[startIndex+k] = 0.0
 	}
 	coef := 1.0
 	if e.averageOutput {
 		coef = 1.0 / float64(nEstimators)
 	}
 	for i := 0; i < nEstimators; i++ {
-		for k := 0; k < e.nClasses; k++ {
-			predictions[startIndex+k] += e.Trees[i*e.nClasses+k].predict(fvals) * coef
+		for k := 0; k < e.nRawOutputGroups; k++ {
+			predictions[startIndex+k] += e.Trees[i*e.nRawOutputGroups+k].predict(fvals) * coef
 		}
 	}
 }

lgensemble_io.go

@@ -289,7 +289,7 @@ func LGEnsembleFromReader(reader *bufio.Reader, loadTransformation bool) (*Ensem
 	} else if nTreePerIteration < 1 {
 		return nil, fmt.Errorf("num_tree_per_iteration (%d) should be > 0", nTreePerIteration)
 	}
-	e.nClasses = nClasses
+	e.nRawOutputGroups = nClasses
 
 	maxFeatureIdx, err := params.ToInt("max_feature_idx")
 	if err != nil {
@@ -312,8 +312,8 @@ func LGEnsembleFromReader(reader *bufio.Reader, loadTransformation bool) (*Ensem
 	nTrees := len(treeSizes)
 	if nTrees == 0 {
 		return nil, fmt.Errorf("no trees in file (based on tree_sizes value)")
-	} else if nTrees%e.nClasses != 0 {
-		return nil, fmt.Errorf("wrong number of trees (%d) for number of class (%d)", nTrees, e.nClasses)
+	} else if nTrees%e.nRawOutputGroups != 0 {
+		return nil, fmt.Errorf("wrong number of trees (%d) for number of class (%d)", nTrees, e.nRawOutputGroups)
 	}
 
 	e.Trees = make([]lgTree, 0, nTrees)
@@ -584,14 +584,14 @@ func LGEnsembleFromJSON(reader io.Reader, loadTransformation bool) (*Ensemble, e
 	} else if data.NumTreesPerIteration < 1 {
 		return nil, fmt.Errorf("num_tree_per_iteration (%d) should be > 0", data.NumTreesPerIteration)
 	}
-	e.nClasses = data.NumClasses
+	e.nRawOutputGroups = data.NumClasses
 	e.MaxFeatureIdx = data.MaxFeatureIdx
 
 	nTrees := len(data.Trees)
 	if nTrees == 0 {
 		return nil, fmt.Errorf("no trees in file (based on tree_sizes value)")
-	} else if nTrees%e.nClasses != 0 {
-		return nil, fmt.Errorf("wrong number of trees (%d) for number of class (%d)", nTrees, e.nClasses)
+	} else if nTrees%e.nRawOutputGroups != 0 {
+		return nil, fmt.Errorf("wrong number of trees (%d) for number of class (%d)", nTrees, e.nRawOutputGroups)
 	}
 
 	e.Trees = make([]lgTree, 0, nTrees)

lgensemble_test.go

@@ -242,8 +242,8 @@ func TestLGEnsembleJSON1tree1leaf(t *testing.T) {
 		t.Fatalf("expected 1 trees (got %d)", model.NEstimators())
 	}
 
-	if model.NClasses() != 1 {
-		t.Fatalf("expected 1 class (got %d)", model.NClasses())
+	if model.NRawOutputGroups() != 1 {
+		t.Fatalf("expected 1 class (got %d)", model.NRawOutputGroups())
 	}
 
 	if model.NFeatures() != 41 {
@@ -273,8 +273,8 @@ func TestLGEnsembleJSON1tree(t *testing.T) {
 		t.Fatalf("expected 1 trees (got %d)", model.NEstimators())
 	}
 
-	if model.NClasses() != 1 {
-		t.Fatalf("expected 1 class (got %d)", model.NClasses())
+	if model.NRawOutputGroups() != 1 {
+		t.Fatalf("expected 1 class (got %d)", model.NRawOutputGroups())
 	}
 
 	if model.NFeatures() != 2 {