func basicComputeLoop(t *testing.T, spParams SpParams) {
	/*
		 Feed in some vectors and retrieve outputs. Ensure the right number of
		columns win, that we always get binary outputs, and that nothing crashes.
	*/

	sp := NewSpatialPooler(spParams)

	// Create a set of input vectors as well as various numpy vectors we will
	// need to retrieve data from the SP
	numRecords := 100

	inputMatrix := make([][]bool, numRecords)
	for i := range inputMatrix {
		inputMatrix[i] = make([]bool, sp.numInputs)
		for j := range inputMatrix[i] {
			inputMatrix[i][j] = rand.Float64() > 0.8
		}
	}

	// With learning off and no prior training we should get no winners
	y := make([]bool, sp.numColumns)
	for _, input := range inputMatrix {
		utils.FillSliceBool(y, false)
		sp.Compute(input, false, y, sp.InhibitColumns)
		assert.Equal(t, 0, utils.CountTrue(y))
	}

	// With learning on we should get the requested number of winners
	for _, input := range inputMatrix {
		utils.FillSliceBool(y, false)
		sp.Compute(input, true, y, sp.InhibitColumns)
		assert.Equal(t, sp.NumActiveColumnsPerInhArea, utils.CountTrue(y))

	}

	// With learning off and some prior training we should get the requested
	// number of winners
	for _, input := range inputMatrix {
		utils.FillSliceBool(y, false)
		sp.Compute(input, false, y, sp.InhibitColumns)
		assert.Equal(t, sp.NumActiveColumnsPerInhArea, utils.CountTrue(y))
	}

}
func phase2(t *testing.T, bt *boostTest) {

	y := make([]bool, bt.sp.numColumns)

	// Do 9 training batch through the input patterns
	for i := 0; i < 9; i++ {
		for idx, input := range bt.x {
			utils.FillSliceBool(y, false)
			bt.sp.Compute(input, true, y, bt.sp.InhibitColumns)
			for j, winner := range y {
				if winner {
					bt.winningIteration[j] = bt.sp.IterationLearnNum
				}
			}
			bt.lastSDR[idx] = y
		}
	}

	// The boost factor for all columns should be at 1.
	assert.Equal(t, bt.sp.numColumns, utils.CountFloat64(bt.sp.boostFactors, 1), "Boost factors are not all 1")

	// Roughly half of the columns should have never been active.
	winners := utils.CountInt(bt.winningIteration, 0)
	assert.True(t, winners >= int(0.4*float64(bt.sp.numColumns)), "More than 60% of the columns have been active")

	// All the never-active columns should have duty cycle of 0
	activeSum := 0.0
	for idx, val := range bt.sp.activeDutyCycles {
		if bt.winningIteration[idx] == 0 {
			activeSum += val
		}
	}
	assert.Equal(t, 0, activeSum, "Inactive columns have positive duty cycle.")

	dutyAvg := 0.0
	dutyCount := 0
	for _, val := range bt.sp.activeDutyCycles {
		if val > 0 {
			dutyAvg += val
			dutyCount++
		}
	}

	// The average at-least-once-active columns should have duty cycle >= 0.15
	// and <= 0.25
	dutyAvg = dutyAvg / float64(dutyCount)
	assert.True(t, dutyAvg >= 0.15, "Average on-columns duty cycle is too low.")
	assert.True(t, dutyAvg <= 0.30, "Average on-columns duty cycle is too high.")

	verifySDRProps(t, bt)
}
Beispiel #3
0
func (tp *TrivialPredictor) reset() {

	for _, method := range tp.Methods {

		utils.FillSliceBool(tp.State[method].ActiveState, false)
		utils.FillSliceBool(tp.State[method].ActiveStateLast, false)
		utils.FillSliceBool(tp.State[method].PredictedState, false)
		utils.FillSliceBool(tp.State[method].PredictedStateLast, false)
		utils.FillSliceFloat64(tp.State[method].Confidence, 0.0)
		utils.FillSliceFloat64(tp.State[method].ConfidenceLast, 0.0)

		stats := tp.InternalStats[method]
		stats.NInfersSinceReset = 0
		stats.CurPredictionScore = 0.0
		stats.CurPredictionScore2 = 0.0
		stats.FalseNegativeScoreTotal = 0.0
		stats.FalsePositiveScoreTotal = 0.0
		stats.CurExtra = 0.0
		stats.CurMissing = 0.0
		tp.InternalStats[method] = stats
	}

}
func phase4(t *testing.T, bt *boostTest) {
	//The boost factor for all columns that just won should be at 1.
	boostAtBeg := make([]float64, len(bt.sp.boostFactors))
	copy(bt.sp.boostFactors, boostAtBeg)

	// Do one more iteration through the input patterns with learning OFF
	y := make([]bool, bt.sp.numColumns)
	for _, input := range bt.x {
		utils.FillSliceBool(y, false)
		bt.sp.Compute(input, false, y, bt.sp.InhibitColumns)

		// The boost factor for all columns that just won should be at 1.
		assert.Equal(t, utils.SumSliceFloat64(boostAtBeg), utils.SumSliceFloat64(bt.sp.boostFactors), "Boost factors changed when learning is off")
	}

}
func phase1(t *testing.T, bt *boostTest) {
	y := make([]bool, bt.sp.numColumns)
	// Do one training batch through the input patterns
	for idx, input := range bt.x {
		utils.FillSliceBool(y, false)
		bt.sp.Compute(input, true, y, bt.sp.InhibitColumns)
		for j, winner := range y {
			if winner {
				bt.winningIteration[j] = bt.sp.IterationLearnNum
			}
		}
		bt.lastSDR[idx] = y
	}

	//The boost factor for all columns should be at 1.
	assert.Equal(t, bt.sp.numColumns, utils.CountFloat64(bt.sp.boostFactors, 1), "Boost factors are not all 1")

	//At least half of the columns should have never been active.
	winners := utils.CountInt(bt.winningIteration, 0)
	assert.True(t, winners >= bt.sp.numColumns/2, "More than half of the columns have been active")

	//All the never-active columns should have duty cycle of 0
	//All the at-least-once-active columns should have duty cycle >= 0.2
	activeSum := 0.0
	for idx, val := range bt.sp.activeDutyCycles {
		if bt.winningIteration[idx] == 0 {
			//assert.Equal(t, expected, actual, ...)
			activeSum += val
		}
	}
	assert.Equal(t, 0, activeSum, "Inactive columns have positive duty cycle.")

	winningMin := 100000.0
	for idx, val := range bt.sp.activeDutyCycles {
		if bt.winningIteration[idx] > 0 {
			if val < winningMin {
				winningMin = val
			}
		}
	}
	assert.True(t, winningMin >= 0.2, "Active columns have duty cycle that is too low.")

	verifySDRProps(t, bt)
}
func phase3(t *testing.T, bt *boostTest) {
	//Do two more training batches through the input patterns
	y := make([]bool, bt.sp.numColumns)

	for i := 0; i < 2; i++ {
		for idx, input := range bt.x {
			utils.FillSliceBool(y, false)
			bt.sp.Compute(input, true, y, bt.sp.InhibitColumns)
			for j, winner := range y {
				if winner {
					bt.winningIteration[j] = bt.sp.IterationLearnNum
				}
			}
			bt.lastSDR[idx] = y
		}
	}

	// The boost factor for all columns that just won should be at 1.
	for idx, val := range y {
		if val {
			if bt.sp.boostFactors[idx] != 1 {
				assert.Fail(t, "Boost factors of winning columns not 1")
			}
		}
	}

	// By now, every column should have been sufficiently boosted to win at least
	// once. The number of columns that have never won should now be 0
	for _, val := range bt.winningIteration {
		if val == 0 {
			assert.Fail(t, "Expected all columns to have won atleast once.")
		}
	}

	// Because of the artificially induced thrashing, even the first two patterns
	// should have low overlap. Verify that the first two SDR's now have little
	// overlap
	overlap := computeOverlap(bt.lastSDR[0], bt.lastSDR[1])
	assert.True(t, overlap < 7, "First two SDR's overlap significantly when they should not")
}
Beispiel #7
0
func (tp *TrivialPredictor) infer(activeColumns []int) {

	numColsToPredict := int(0.5 + tp.AverageDensity*float64(tp.NumOfCols))

	//for method in self.methods:
	for _, method := range tp.Methods {
		// Copy t-1 into t
		copy(tp.State[method].ActiveStateLast, tp.State[method].ActiveState)
		copy(tp.State[method].PredictedStateLast, tp.State[method].PredictedState)
		copy(tp.State[method].ConfidenceLast, tp.State[method].Confidence)

		utils.FillSliceBool(tp.State[method].ActiveState, false)
		utils.FillSliceBool(tp.State[method].PredictedState, false)
		utils.FillSliceFloat64(tp.State[method].Confidence, 0.0)

		for _, val := range activeColumns {
			tp.State[method].ActiveState[val] = true
		}

		var predictedCols []int

		switch method {
		case Random:
			// Randomly predict N columns
			//predictedCols = RandomInts(numColsToPredict, tp.NumOfCols)
			break
		case Zeroth:
			// Always predict the top N most frequent columns
			var inds []int
			ints.Argsort(tp.ColumnCount, inds)
			predictedCols = inds[len(inds)-numColsToPredict:]
			break
		case Last:
			// Always predict the last input
			for idx, val := range tp.State[method].ActiveState {
				if val {
					predictedCols = append(predictedCols, idx)
				}
			}
			break
		case All:
			// Always predict all columns
			for i := 0; i < tp.NumOfCols; i++ {
				predictedCols = append(predictedCols, i)
			}
			break
		case Lots:
			// Always predict 2 * the top N most frequent columns
			numColsToPredict := mathutil.Min(2*numColsToPredict, tp.NumOfCols)
			var inds []int
			ints.Argsort(tp.ColumnCount, inds)
			predictedCols = inds[len(inds)-numColsToPredict:]

			break
		default:
			panic("prediction method not implemented")
		}

		for _, val := range predictedCols {
			tp.State[method].PredictedState[val] = true
			tp.State[method].Confidence[val] = 1.0
		}

		if tp.Verbosity > 1 {
			fmt.Println("Random prediction:", method)
			fmt.Println(" numColsToPredict:", numColsToPredict)
			fmt.Println(predictedCols)
		}

	}

}
Beispiel #8
0
//Clears  all entries
func (sm *DenseBinaryMatrix) Clear() {
	utils.FillSliceBool(sm.entries, false)
}