Example #1
0
func TestShouldBeCompatibleWeightPanicsForMatricsWithDifferentDimensions(t *testing.T) {
	test := weightUpdateTest{
		old:    dense.Zeros(4, 8),
		update: dense.Zeros(4, 10),
	}

	defer func() {
		if p := recover(); p != INCOMPATIBLE_WEIGHTS_PANIC {
			t.Fatalf("%s should be caused, but %s causes", INCOMPATIBLE_WEIGHTS_PANIC, p)
		}
	}()
	ShouldBeCompatibleWeights(test.old, test.update)
}
Example #2
0
func TestShouldBeCompatibleWeightSucceedsForSameShapeMatrices(t *testing.T) {
	test := weightUpdateTest{
		old:    dense.Zeros(4, 8),
		update: dense.Zeros(4, 8),
	}

	defer func() {
		if p := recover(); p != nil {
			t.Fatalf(
				"Weights validation should not cause any panic for the same shape one: %s",
				p,
			)
		}
	}()
	ShouldBeCompatibleWeights(test.old, test.update)
}
Example #3
0
func TestShouldBeFeaturePanicsForNonFeature(t *testing.T) {
	test := dense.Zeros(4, 1)

	defer func() {
		if p := recover(); p != NON_FEATURE_MATRIX_PANIC {
			t.Fatalf("%s should be caused, but %s causes", NON_FEATURE_MATRIX_PANIC, p)
		}
	}()
	ShouldBeFeature(test)
}
Example #4
0
// Create a new classifier with the given number of classes and dimensions of features.
// The generate classifier has a weight matrix with zeros.
func New(classSize, dimensions int) *Classifier {
	validates.ShouldBeOneOrMoreClasses(classSize)

	c := &Classifier{
		initialized: true,
		// TODO: Replace the weights with the immutable version of dense matrix.
		weights: dense.Zeros(classSize, dimensions),
	}

	return c
}
Example #5
0
func TestWeightsReturnsTheWeightsMatrix(t *testing.T) {
	test := constructionTest{
		classSize:  4,
		dimensions: 8,
	}

	c := New(test.classSize, test.dimensions)
	zeroMatrix := dense.Zeros(test.classSize, test.dimensions)

	if weights := c.Weights(); !weights.Equal(zeroMatrix) {
		t.Fatalf("A %d x %d matrix should be returned as the weights matrix.", 4, 8)
	}
}
Example #6
0
func TestShouldBeFeatureSucceedsForFeature(t *testing.T) {
	test := dense.Zeros(1, 1)

	defer func() {
		if p := recover(); p != nil {
			t.Fatalf(
				"Feature validation should not cause any panic for feature matirx: %s",
				p,
			)
		}
	}()
	ShouldBeFeature(test)
}
Example #7
0
func TestUnmarshalJSONFailsWithIncompatibleVersion(t *testing.T) {
	c := &classifierJson{
		Version: 99999,
		Weights: dense.Zeros(4, 8),
	}

	d := &Classifier{}

	b, _ := json.Marshal(c)

	if err := json.Unmarshal(b, d); err == nil || err.Error() != IncompatibleVersionError {
		t.Fatalf("Unmarshal can be applied to compatible-version classifier.")
	}
}
Example #8
0
func TestClassifyPanicsByNonFeatureMatrix(t *testing.T) {
	classSize, dimensions := 4, 8

	test := dense.Zeros(classSize, dimensions+1)

	defer func() {
		if p := recover(); p == NON_FEATURE_MATRIX_PANIC {
			return
		}

		t.Fatal("Update should use \"validate.ShouldBeFeature\".")
	}()
	New(classSize, dimensions).Classify(test)
}
Example #9
0
func TestUpdatePanicsByIncompatibleWeights(t *testing.T) {
	classSize, dimensions := 4, 8
	test := dense.Zeros(classSize+1, dimensions)

	c := New(classSize, dimensions)

	defer func() {
		if p := recover(); p == INCOMPATIBLE_WEIGHTS_PANIC {
			return
		}

		t.Fatal("Update should use \"validate.ShouldBeCompatibleWeights\".")
	}()
	c.Update(test)
}
Example #10
0
func TestUpdateSucceedsForMatricesWithSameShape(t *testing.T) {
	classSize, dimensions := 4, 8
	test := dense.Zeros(classSize, dimensions)

	c := New(classSize, dimensions)

	defer func() {
		if p := recover(); p == nil {
			return
		}

		t.Fatal("Update should not panic for the weights as same shape as the old.")
	}()
	c.Update(test)
}