func TestUpdateMinDutyCyclesGlobal(t *testing.T) {
sp := SpatialPooler{}
sp.MinPctActiveDutyCycles = 0.02
sp.MinPctOverlapDutyCycles = 0.01
sp.numColumns = 5
sp.overlapDutyCycles = []float64{0.06, 1, 3, 6, 0.5}
sp.activeDutyCycles = []float64{0.6, 0.07, 0.5, 0.4, 0.3}
sp.minOverlapDutyCycles = make([]float64, sp.numColumns)
sp.minActiveDutyCycles = make([]float64, sp.numColumns)
sp.updateMinDutyCyclesGlobal()
trueMinActiveDutyCycles := utils.MakeSliceFloat64(sp.numColumns, 0.02*0.6)
trueMinOverlapDutyCycles := utils.MakeSliceFloat64(sp.numColumns, 0.01*6)
assert.Equal(t, 5, len(sp.minActiveDutyCycles))
assert.Equal(t, 5, len(sp.minOverlapDutyCycles))
for i := 0; i < sp.numColumns; i++ {
assert.AlmostEqualFloat(t, trueMinActiveDutyCycles[i], sp.minActiveDutyCycles[i])
assert.AlmostEqualFloat(t, trueMinOverlapDutyCycles[i], sp.minOverlapDutyCycles[i])
}
sp.MinPctOverlapDutyCycles = 0.015
sp.MinPctActiveDutyCycles = 0.03
sp.numColumns = 5
sp.overlapDutyCycles = []float64{0.86, 2.4, 0.03, 1.6, 1.5}
sp.activeDutyCycles = []float64{0.16, 0.007, 0.15, 0.54, 0.13}
sp.updateMinDutyCyclesGlobal()
trueMinOverlapDutyCycles = utils.MakeSliceFloat64(sp.numColumns, 0.015*2.4)
for i := 0; i < sp.numColumns; i++ {
assert.AlmostEqualFloat(t, trueMinOverlapDutyCycles[i], sp.minOverlapDutyCycles[i])
}
sp.MinPctOverlapDutyCycles = 0.015
sp.MinPctActiveDutyCycles = 0.03
sp.numColumns = 5
sp.overlapDutyCycles = utils.MakeSliceFloat64(sp.numColumns, 0)
sp.activeDutyCycles = utils.MakeSliceFloat64(sp.numColumns, 0)
sp.updateMinDutyCyclesGlobal()
trueMinActiveDutyCycles = utils.MakeSliceFloat64(sp.numColumns, 0)
trueMinOverlapDutyCycles = utils.MakeSliceFloat64(sp.numColumns, 0)
assert.Equal(t, 5, len(sp.minActiveDutyCycles))
assert.Equal(t, 5, len(sp.minOverlapDutyCycles))
for i := 0; i < sp.numColumns; i++ {
assert.AlmostEqualFloat(t, trueMinActiveDutyCycles[i], sp.minActiveDutyCycles[i])
assert.AlmostEqualFloat(t, trueMinOverlapDutyCycles[i], sp.minOverlapDutyCycles[i])
}
}
func TestBumpUpWeakColumns(t *testing.T) {
sp := SpatialPooler{}
sp.numInputs = 8
sp.InputDimensions = []int{8}
sp.numColumns = 5
sp.ColumnDimensions = []int{5}
sp.SynPermBelowStimulusInc = 0.01
sp.SynPermTrimThreshold = 0.05
sp.overlapDutyCycles = []float64{0, 0.009, 0.1, 0.001, 0.002}
sp.minOverlapDutyCycles = utils.MakeSliceFloat64(5, 0.01)
sp.SynPermInactiveDec = 0.01
sp.SynPermActiveInc = 0.1
sp.connectedSynapses = NewDenseBinaryMatrix(sp.numColumns, sp.numInputs)
sp.connectedCounts = make([]int, sp.numColumns)
sp.SynPermMax = 1
sp.SynPermMin = 0
sp.SynPermConnected = 0.10
sp.MinPctOverlapDutyCycles = 0.1
sp.MinPctActiveDutyCycles = 0.1
sp.DutyCyclePeriod = 10
sp.MaxBoost = 10.0
sp.PotentialRadius = 5
sp.PotentialPct = 0.5
ints := [][]int{{1, 1, 1, 1, 0, 0, 0, 0},
{1, 0, 0, 0, 1, 1, 0, 1},
{0, 0, 1, 0, 1, 1, 1, 0},
{1, 1, 1, 0, 0, 0, 1, 0},
{1, 1, 1, 1, 1, 1, 1, 1}}
sp.potentialPools = NewDenseBinaryMatrixFromInts(ints)
floats := []float64{0.200, 0.120, 0.090, 0.040, 0.000, 0.000, 0.000, 0.000,
0.150, 0.000, 0.000, 0.000, 0.180, 0.120, 0.000, 0.450,
0.000, 0.000, 0.014, 0.000, 0.032, 0.044, 0.110, 0.000,
0.041, 0.000, 0.000, 0.000, 0.000, 0.000, 0.178, 0.000,
0.100, 0.738, 0.045, 0.002, 0.050, 0.008, 0.208, 0.034}
elms := make(map[int]float64, len(floats))
for i, val := range floats {
elms[i] = val
}
sp.permanences = matrix.MakeSparseMatrix(elms, 5, 8)
truePermanences := [][]float64{
{0.210, 0.130, 0.100, 0.000, 0.000, 0.000, 0.000, 0.000},
// Inc Inc Inc Trim - - - -
{0.160, 0.000, 0.000, 0.000, 0.190, 0.130, 0.000, 0.460},
// Inc - - - Inc Inc - Inc
{0.000, 0.000, 0.014, 0.000, 0.032, 0.044, 0.110, 0.000}, //unchanged
// - - - - - - - -
{0.051, 0.000, 0.000, 0.000, 0.000, 0.000, 0.188, 0.000},
// Inc Trim Trim - - - Inc -
{0.110, 0.748, 0.055, 0.000, 0.060, 0.000, 0.218, 0.000}}
sp.bumpUpWeakColumns()
for i := 0; i < sp.numColumns; i++ {
for j := 0; j < sp.numInputs; j++ {
assert.AlmostEqualFloat(t, truePermanences[i][j], sp.permanences.Get(i, j), strconv.Itoa(i)+" "+strconv.Itoa(j))
}
}
}
func TestUpdateMinDutyCyclesLocal(t *testing.T) {
sp := SpatialPooler{}
sp.ColumnDimensions = []int{5}
sp.numColumns = 5
neighborsValue := [][]int{{0, 1, 2},
{1, 2, 3},
{2, 3, 4},
{0, 2, 4},
{0, 1, 3},
}
callCount := 0
getNeighborsMock := func(columnIndex int, dimensions []int, radius int, wrapAround bool) []int {
//t.Logf("called mock")
result := neighborsValue[callCount]
callCount++
return result
}
sp.MinPctOverlapDutyCycles = 0.04
sp.overlapDutyCycles = []float64{1.4, 0.5, 1.2, 0.8, 0.1}
trueMinOverlapDutyCycles := []float64{0.04 * 1.4, 0.04 * 1.2, 0.04 * 1.2, 0.04 * 1.4, 0.04 * 1.4}
sp.MinPctActiveDutyCycles = 0.02
sp.activeDutyCycles = []float64{0.4, 0.5, 0.2, 0.18, 0.1}
trueMinActiveDutyCycles := []float64{0.02 * 0.5, 0.02 * 0.5, 0.02 * 0.2, 0.02 * 0.4, 0.02 * 0.5}
sp.minOverlapDutyCycles = utils.MakeSliceFloat64(sp.numColumns, 0)
sp.minActiveDutyCycles = utils.MakeSliceFloat64(sp.numColumns, 0)
sp.updateMinDutyCyclesLocal(getNeighborsMock)
//assert.Equal(t, trueMinOverlapDutyCycles, sp.minOverlapDutyCycles)
for i, _ := range trueMinOverlapDutyCycles {
assert.AlmostEqualFloat(t, trueMinOverlapDutyCycles[i], sp.minOverlapDutyCycles[i])
}
assert.Equal(t, trueMinActiveDutyCycles, sp.minActiveDutyCycles)
// 2-----
sp.ColumnDimensions = []int{8}
sp.numColumns = 8
neighborsValue = [][]int{{0, 1, 2, 3, 4},
{1, 2, 3, 4, 5},
{2, 3, 4, 6, 7},
{0, 2, 4, 6},
{1, 6},
{3, 5, 7},
{1, 4, 5, 6},
{2, 3, 6, 7}}
sp.MinPctOverlapDutyCycles = 0.01
sp.overlapDutyCycles = []float64{1.2, 2.7, 0.9, 1.1, 4.3, 7.1, 2.3, 0.0}
trueMinOverlapDutyCycles = []float64{0.01 * 4.3, 0.01 * 7.1, 0.01 * 4.3, 0.01 * 4.3,
0.01 * 4.3, 0.01 * 7.1, 0.01 * 7.1, 0.01 * 2.3}
sp.MinPctActiveDutyCycles = 0.03
sp.activeDutyCycles = []float64{0.14, 0.25, 0.125, 0.33, 0.27, 0.11, 0.76, 0.31}
trueMinActiveDutyCycles = []float64{0.03 * 0.33, 0.03 * 0.33, 0.03 * 0.76, 0.03 * 0.76,
0.03 * 0.76, 0.03 * 0.33, 0.03 * 0.76, 0.03 * 0.76}
sp.minOverlapDutyCycles = utils.MakeSliceFloat64(sp.numColumns, 0)
sp.minActiveDutyCycles = utils.MakeSliceFloat64(sp.numColumns, 0)
callCount = 0
sp.updateMinDutyCyclesLocal(getNeighborsMock)
assert.Equal(t, trueMinOverlapDutyCycles, sp.minOverlapDutyCycles)
assert.Equal(t, trueMinActiveDutyCycles, sp.minActiveDutyCycles)
}
func TestAdaptSynapses(t *testing.T) {
sp := SpatialPooler{}
sp.InputDimensions = []int{8}
sp.ColumnDimensions = []int{4}
sp.numInputs = 8
sp.numColumns = 4
sp.SynPermInactiveDec = 0.01
sp.SynPermActiveInc = 0.1
sp.SynPermTrimThreshold = 0.05
sp.connectedSynapses = NewDenseBinaryMatrix(sp.numColumns, sp.numInputs)
sp.connectedCounts = make([]int, sp.numColumns)
sp.SynPermMax = 1
sp.SynPermMin = 0
ints := [][]int{{1, 1, 1, 1, 0, 0, 0, 0},
{1, 0, 0, 0, 1, 1, 0, 1},
{0, 0, 1, 0, 0, 0, 1, 0},
{1, 0, 0, 0, 0, 0, 1, 0}}
sp.potentialPools = NewDenseBinaryMatrixFromInts(ints)
inputVector := []bool{true, false, false, true, true, false, true, false}
activeColumns := []int{0, 1, 2}
floats := []float64{0.200, 0.120, 0.090, 0.040, 0.000, 0.000, 0.000, 0.000,
0.150, 0.000, 0.000, 0.000, 0.180, 0.120, 0.000, 0.450,
0.000, 0.000, 0.014, 0.000, 0.000, 0.000, 0.110, 0.000,
0.040, 0.000, 0.000, 0.000, 0.000, 0.000, 0.178, 0.000}
elms := make(map[int]float64, len(floats))
for i, val := range floats {
elms[i] = val
}
sp.permanences = matrix.MakeSparseMatrix(elms, 4, 8)
truePermanences := [][]float64{
{0.300, 0.110, 0.080, 0.140, 0.000, 0.000, 0.000, 0.000},
// Inc Dec Dec Inc - - - -
{0.250, 0.000, 0.000, 0.000, 0.280, 0.110, 0.000, 0.440},
// Inc - - - Inc Dec - Dec
{0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.210, 0.000},
// - - Trim - - - Inc -
{0.040, 0.000, 0.000, 0.000, 0.000, 0.000, 0.178, 0.000}}
// - - - - - - - -
sp.adaptSynapses(inputVector, activeColumns)
for i := 0; i < sp.numColumns; i++ {
for j := 0; j < sp.numInputs; j++ {
expected := truePermanences[i][j]
actual := sp.permanences.Get(i, j)
assert.AlmostEqualFloat(t, expected, actual)
}
}
ints = [][]int{{1, 1, 1, 0, 0, 0, 0, 0},
{0, 1, 1, 1, 0, 0, 0, 0},
{0, 0, 1, 1, 1, 0, 0, 0},
{1, 0, 0, 0, 0, 0, 1, 0}}
sp.potentialPools = NewDenseBinaryMatrixFromInts(ints)
inputVector = []bool{true, false, false, true, true, false, true, false}
activeColumns = []int{0, 1, 2}
floats = []float64{0.200, 0.120, 0.090, 0.000, 0.000, 0.000, 0.000, 0.000,
0.000, 0.017, 0.232, 0.400, 0.000, 0.000, 0.000, 0.000,
0.000, 0.000, 0.014, 0.051, 0.730, 0.000, 0.000, 0.000,
0.170, 0.000, 0.000, 0.000, 0.000, 0.000, 0.380, 0.000}
for i, val := range floats {
elms[i] = val
}
sp.permanences = matrix.MakeSparseMatrix(elms, 4, 8)
truePermanences = [][]float64{
{0.30, 0.110, 0.080, 0.000, 0.000, 0.000, 0.000, 0.000},
// Inc Dec Dec - - - - -
{0.000, 0.000, 0.222, 0.500, 0.000, 0.000, 0.000, 0.000},
// - Trim Dec Inc - - - -
{0.000, 0.000, 0.000, 0.151, 0.830, 0.000, 0.000, 0.000},
// - - Trim Inc Inc - - -
{0.170, 0.000, 0.000, 0.000, 0.000, 0.000, 0.380, 0.000}}
// - - - - - - - -
sp.adaptSynapses(inputVector, activeColumns)
for i := 0; i < sp.numColumns; i++ {
for j := 0; j < sp.numInputs; j++ {
expected := truePermanences[i][j]
actual := sp.permanences.Get(i, j)
assert.AlmostEqualFloat(t, expected, actual)
}
}
}
