package org.numenta.nupic.algorithms;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.junit.Test;
import org.numenta.nupic.Parameters;
import org.numenta.nupic.Parameters.KEY;
import org.numenta.nupic.model.Cell;
import org.numenta.nupic.model.Column;
import org.numenta.nupic.model.ComputeCycle;
import org.numenta.nupic.model.Connections;
import org.numenta.nupic.model.DistalDendrite;
import org.numenta.nupic.model.Synapse;
import org.numenta.nupic.util.UniversalRandom;
import org.nustaq.serialization.FSTConfiguration;
public class TemporalMemoryTest {
private Parameters getDefaultParameters() {
Parameters retVal = Parameters.getTemporalDefaultParameters();
retVal.set(KEY.COLUMN_DIMENSIONS, new int[] { 32 });
retVal.set(KEY.CELLS_PER_COLUMN, 4);
retVal.set(KEY.ACTIVATION_THRESHOLD, 3);
retVal.set(KEY.INITIAL_PERMANENCE, 0.21);
retVal.set(KEY.CONNECTED_PERMANENCE, 0.5);
retVal.set(KEY.MIN_THRESHOLD, 2);
retVal.set(KEY.MAX_NEW_SYNAPSE_COUNT, 3);
retVal.set(KEY.PERMANENCE_INCREMENT, 0.10);
retVal.set(KEY.PERMANENCE_DECREMENT, 0.10);
retVal.set(KEY.PREDICTED_SEGMENT_DECREMENT, 0.0);
retVal.set(KEY.RANDOM, new UniversalRandom(42));
retVal.set(KEY.SEED, 42);
return retVal;
}
private Parameters getDefaultParameters(Parameters p, KEY key, Object value) {
Parameters retVal = p == null ? getDefaultParameters() : p;
retVal.set(key, value);
return retVal;
}
@SuppressWarnings("unchecked")
private <T> T deepCopyPlain(T t) {
FSTConfiguration fastSerialConfig = FSTConfiguration.createDefaultConfiguration();
byte[] bytes = fastSerialConfig.asByteArray(t);
return (T)fastSerialConfig.asObject(bytes);
}
@Test
public void testActivateCorrectlyPredictiveCells() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = getDefaultParameters();
p.apply(cn);
TemporalMemory.init(cn);
int[] previousActiveColumns = { 0 };
int[] activeColumns = { 1 };
Cell cell4 = cn.getCell(4);
Set<Cell> expectedActiveCells = Stream.of(cell4).collect(Collectors.toSet());
DistalDendrite activeSegment = cn.createSegment(cell4);
cn.createSynapse(activeSegment, cn.getCell(0), 0.5);
cn.createSynapse(activeSegment, cn.getCell(1), 0.5);
cn.createSynapse(activeSegment, cn.getCell(2), 0.5);
cn.createSynapse(activeSegment, cn.getCell(3), 0.5);
ComputeCycle cc = tm.compute(cn, previousActiveColumns, true);
assertTrue(cc.predictiveCells().equals(expectedActiveCells));
ComputeCycle cc2 = tm.compute(cn, activeColumns, true);
assertTrue(cc2.activeCells().equals(expectedActiveCells));
}
@Test
public void testBurstUnpredictedColumns() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = getDefaultParameters();
p.apply(cn);
TemporalMemory.init(cn);
int[] activeColumns = { 0 };
Set<Cell> burstingCells = cn.getCellSet(new int[] { 0, 1, 2, 3 });
ComputeCycle cc = tm.compute(cn, activeColumns, true);
assertTrue(cc.activeCells().equals(burstingCells));
}
@Test
public void testZeroActiveColumns() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = getDefaultParameters();
p.apply(cn);
TemporalMemory.init(cn);
int[] previousActiveColumns = { 0 };
Cell cell4 = cn.getCell(4);
DistalDendrite activeSegment = cn.createSegment(cell4);
cn.createSynapse(activeSegment, cn.getCell(0), 0.5);
cn.createSynapse(activeSegment, cn.getCell(1), 0.5);
cn.createSynapse(activeSegment, cn.getCell(2), 0.5);
cn.createSynapse(activeSegment, cn.getCell(3), 0.5);
ComputeCycle cc = tm.compute(cn, previousActiveColumns, true);
assertFalse(cc.activeCells().size() == 0);
assertFalse(cc.winnerCells().size() == 0);
assertFalse(cc.predictiveCells().size() == 0);
int[] zeroColumns = new int[0];
ComputeCycle cc2 = tm.compute(cn, zeroColumns, true);
assertTrue(cc2.activeCells().size() == 0);
assertTrue(cc2.winnerCells().size() == 0);
assertTrue(cc2.predictiveCells().size() == 0);
}
@Test
public void testPredictedActiveCellsAreAlwaysWinners() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = getDefaultParameters();
p.apply(cn);
TemporalMemory.init(cn);
int[] previousActiveColumns = { 0 };
int[] activeColumns = { 1 };
Cell[] previousActiveCells = { cn.getCell(0), cn.getCell(1), cn.getCell(2), cn.getCell(3) };
List<Cell> expectedWinnerCells = new ArrayList<>(cn.getCellSet(new int[] { 4, 6 }));
DistalDendrite activeSegment1 = cn.createSegment(expectedWinnerCells.get(0));
cn.createSynapse(activeSegment1, previousActiveCells[0], 0.5);
cn.createSynapse(activeSegment1, previousActiveCells[1], 0.5);
cn.createSynapse(activeSegment1, previousActiveCells[2], 0.5);
DistalDendrite activeSegment2 = cn.createSegment(expectedWinnerCells.get(1));
cn.createSynapse(activeSegment2, previousActiveCells[0], 0.5);
cn.createSynapse(activeSegment2, previousActiveCells[1], 0.5);
cn.createSynapse(activeSegment2, previousActiveCells[2], 0.5);
ComputeCycle cc = tm.compute(cn, previousActiveColumns, false); // learn=false
cc = tm.compute(cn, activeColumns, false); // learn=false
assertTrue(cc.winnerCells.equals(new LinkedHashSet<Cell>(expectedWinnerCells)));
}
@Test
public void testReinforcedCorrectlyActiveSegments() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = getDefaultParameters(null, KEY.INITIAL_PERMANENCE, 0.2);
p = getDefaultParameters(p, KEY.MAX_NEW_SYNAPSE_COUNT, 4);
p = getDefaultParameters(p, KEY.PERMANENCE_DECREMENT, 0.08);
p = getDefaultParameters(p, KEY.PREDICTED_SEGMENT_DECREMENT, 0.02);
p.apply(cn);
TemporalMemory.init(cn);
int[] previousActiveColumns = { 0 };
int[] activeColumns = { 1 };
Cell[] previousActiveCells = {cn.getCell(0), cn.getCell(1), cn.getCell(2), cn.getCell(3) };
Cell activeCell = cn.getCell(5);
DistalDendrite activeSegment = cn.createSegment(activeCell);
Synapse as1 = cn.createSynapse(activeSegment, previousActiveCells[0], 0.5);
Synapse as2 = cn.createSynapse(activeSegment, previousActiveCells[1], 0.5);
Synapse as3 = cn.createSynapse(activeSegment, previousActiveCells[2], 0.5);
Synapse is1 = cn.createSynapse(activeSegment, cn.getCell(81), 0.5);
tm.compute(cn, previousActiveColumns, true);
tm.compute(cn, activeColumns, true);
assertEquals(0.6, as1.getPermanence(), 0.1);
assertEquals(0.6, as2.getPermanence(), 0.1);
assertEquals(0.6, as3.getPermanence(), 0.1);
assertEquals(0.42, is1.getPermanence(), 0.001);
}
@Test
public void testReinforcedSelectedMatchingSegmentInBurstingColumn() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = getDefaultParameters(null, KEY.PERMANENCE_DECREMENT, 0.08);
p.apply(cn);
TemporalMemory.init(cn);
int[] previousActiveColumns = { 0 };
int[] activeColumns = { 1 };
Cell[] previousActiveCells = {cn.getCell(0), cn.getCell(1), cn.getCell(2), cn.getCell(3) };
Cell[] burstingCells = {cn.getCell(4), cn.getCell(5) };
DistalDendrite activeSegment = cn.createSegment(burstingCells[0]);
Synapse as1 = cn.createSynapse(activeSegment, previousActiveCells[0], 0.3);
Synapse as2 = cn.createSynapse(activeSegment, previousActiveCells[0], 0.3);
Synapse as3 = cn.createSynapse(activeSegment, previousActiveCells[0], 0.3);
Synapse is1 = cn.createSynapse(activeSegment, cn.getCell(81), 0.3);
DistalDendrite otherMatchingSegment = cn.createSegment(burstingCells[1]);
cn.createSynapse(otherMatchingSegment, previousActiveCells[0], 0.3);
cn.createSynapse(otherMatchingSegment, previousActiveCells[1], 0.3);
cn.createSynapse(otherMatchingSegment, cn.getCell(81), 0.3);
tm.compute(cn, previousActiveColumns, true);
tm.compute(cn, activeColumns, true);
assertEquals(0.4, as1.getPermanence(), 0.01);
assertEquals(0.4, as2.getPermanence(), 0.01);
assertEquals(0.4, as3.getPermanence(), 0.01);
assertEquals(0.22, is1.getPermanence(), 0.001);
}
@Test
public void testNoChangeToNonSelectedMatchingSegmentsInBurstingColumn() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = getDefaultParameters(null, KEY.PERMANENCE_DECREMENT, 0.08);
p.apply(cn);
TemporalMemory.init(cn);
int[] previousActiveColumns = { 0 };
int[] activeColumns = { 1 };
Cell[] previousActiveCells = {cn.getCell(0), cn.getCell(1), cn.getCell(2), cn.getCell(3) };
Cell[] burstingCells = {cn.getCell(4), cn.getCell(5) };
DistalDendrite selectedMatchingSegment = cn.createSegment(burstingCells[0]);
cn.createSynapse(selectedMatchingSegment, previousActiveCells[0], 0.3);
cn.createSynapse(selectedMatchingSegment, previousActiveCells[1], 0.3);
cn.createSynapse(selectedMatchingSegment, previousActiveCells[2], 0.3);
cn.createSynapse(selectedMatchingSegment, cn.getCell(81), 0.3);
DistalDendrite otherMatchingSegment = cn.createSegment(burstingCells[1]);
Synapse as1 = cn.createSynapse(otherMatchingSegment, previousActiveCells[0], 0.3);
Synapse as2 = cn.createSynapse(otherMatchingSegment, previousActiveCells[1], 0.3);
Synapse is1 = cn.createSynapse(otherMatchingSegment, cn.getCell(81), 0.3);
tm.compute(cn, previousActiveColumns, true);
tm.compute(cn, activeColumns, true);
assertEquals(0.3, as1.getPermanence(), 0.01);
assertEquals(0.3, as2.getPermanence(), 0.01);
assertEquals(0.3, is1.getPermanence(), 0.01);
}
@Test
public void testNoChangeToMatchingSegmentsInPredictedActiveColumn() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = getDefaultParameters();
p.apply(cn);
TemporalMemory.init(cn);
int[] previousActiveColumns = { 0 };
int[] activeColumns = { 1 };
Cell[] previousActiveCells = {cn.getCell(0), cn.getCell(1), cn.getCell(2), cn.getCell(3) };
Cell expectedActiveCell = cn.getCell(4);
Set<Cell> expectedActiveCells = Stream.of(expectedActiveCell).collect(Collectors.toCollection(LinkedHashSet<Cell>::new));
Cell otherBurstingCell = cn.getCell(5);
DistalDendrite activeSegment = cn.createSegment(expectedActiveCell);
cn.createSynapse(activeSegment, previousActiveCells[0], 0.5);
cn.createSynapse(activeSegment, previousActiveCells[1], 0.5);
cn.createSynapse(activeSegment, previousActiveCells[2], 0.5);
cn.createSynapse(activeSegment, previousActiveCells[3], 0.5);
DistalDendrite matchingSegmentOnSameCell = cn.createSegment(expectedActiveCell);
Synapse s1 = cn.createSynapse(matchingSegmentOnSameCell, previousActiveCells[0], 0.3);
Synapse s2 = cn.createSynapse(matchingSegmentOnSameCell, previousActiveCells[1], 0.3);
DistalDendrite matchingSegmentOnOtherCell = cn.createSegment(otherBurstingCell);
Synapse s3 = cn.createSynapse(matchingSegmentOnOtherCell, previousActiveCells[0], 0.3);
Synapse s4 = cn.createSynapse(matchingSegmentOnOtherCell, previousActiveCells[1], 0.3);
ComputeCycle cc = tm.compute(cn, previousActiveColumns, true);
assertTrue(cc.predictiveCells().equals(expectedActiveCells));
tm.compute(cn, activeColumns, true);
assertEquals(0.3, s1.getPermanence(), 0.01);
assertEquals(0.3, s2.getPermanence(), 0.01);
assertEquals(0.3, s3.getPermanence(), 0.01);
assertEquals(0.3, s4.getPermanence(), 0.01);
}
@Test
public void testNoNewSegmentIfNotEnoughWinnerCells() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = getDefaultParameters(null, KEY.MAX_NEW_SYNAPSE_COUNT, 3);
p.apply(cn);
TemporalMemory.init(cn);
int[] zeroColumns = {};
int[] activeColumns = { 0 };
tm.compute(cn, zeroColumns, true);
tm.compute(cn, activeColumns, true);
assertEquals(0, cn.numSegments(), 0);
}
@Test
public void testNewSegmentAddSynapsesToSubsetOfWinnerCells() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = getDefaultParameters(null, KEY.MAX_NEW_SYNAPSE_COUNT, 2);
p.apply(cn);
TemporalMemory.init(cn);
int[] previousActiveColumns = { 0, 1, 2 };
int[] activeColumns = { 4 };
ComputeCycle cc = tm.compute(cn, previousActiveColumns, true);
Set<Cell> prevWinnerCells = cc.winnerCells();
assertEquals(3, prevWinnerCells.size());
cc = tm.compute(cn, activeColumns, true);
List<Cell> winnerCells = new ArrayList<>(cc.winnerCells());
assertEquals(1, winnerCells.size());
List<DistalDendrite> segments = winnerCells.get(0).getSegments(cn);
assertEquals(1, segments.size());
List<Synapse> synapses = cn.getSynapses(segments.get(0));
assertEquals(2, synapses.size());
for(Synapse synapse : synapses) {
assertEquals(0.21, synapse.getPermanence(), 0.01);
assertTrue(prevWinnerCells.contains(synapse.getPresynapticCell()));
}
}
@Test
public void testNewSegmentAddSynapsesToAllWinnerCells() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = getDefaultParameters(null, KEY.MAX_NEW_SYNAPSE_COUNT, 4);
p.apply(cn);
TemporalMemory.init(cn);
int[] previousActiveColumns = { 0, 1, 2 };
int[] activeColumns = { 4 };
ComputeCycle cc = tm.compute(cn, previousActiveColumns, true);
List<Cell> prevWinnerCells = new ArrayList<>(cc.winnerCells());
assertEquals(3, prevWinnerCells.size());
cc = tm.compute(cn, activeColumns, true);
List<Cell> winnerCells = new ArrayList<>(cc.winnerCells());
assertEquals(1, winnerCells.size());
List<DistalDendrite> segments = winnerCells.get(0).getSegments(cn);
assertEquals(1, segments.size());
List<Synapse> synapses = segments.get(0).getAllSynapses(cn);
List<Cell> presynapticCells = new ArrayList<>();
for(Synapse synapse : synapses) {
assertEquals(0.21, synapse.getPermanence(), 0.01);
presynapticCells.add(synapse.getPresynapticCell());
}
Collections.sort(presynapticCells);
assertTrue(prevWinnerCells.equals(presynapticCells));
}
@Test
public void testMatchingSegmentAddSynapsesToSubsetOfWinnerCells() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = getDefaultParameters(null, KEY.CELLS_PER_COLUMN, 1);
p = getDefaultParameters(p, KEY.MIN_THRESHOLD, 1);
p.apply(cn);
TemporalMemory.init(cn);
int[] previousActiveColumns = { 0, 1, 2, 3 };
Set<Cell> prevWinnerCells = cn.getCellSet(new int[] { 0, 1, 2, 3 });
int[] activeColumns = { 4 };
DistalDendrite matchingSegment = cn.createSegment(cn.getCell(4));
cn.createSynapse(matchingSegment, cn.getCell(0), 0.5);
ComputeCycle cc = tm.compute(cn, previousActiveColumns, true);
assertTrue(cc.winnerCells().equals(prevWinnerCells));
cc = tm.compute(cn, activeColumns, true);
List<Synapse> synapses = cn.getSynapses(matchingSegment);
assertEquals(3, synapses.size());
Collections.sort(synapses);
for(Synapse synapse : synapses) {
if(synapse.getPresynapticCell().getIndex() == 0) continue;
assertEquals(0.21, synapse.getPermanence(), 0.01);
assertTrue(synapse.getPresynapticCell().getIndex() == 1 ||
synapse.getPresynapticCell().getIndex() == 2 ||
synapse.getPresynapticCell().getIndex() == 3);
}
}
@Test
public void testMatchingSegmentAddSynapsesToAllWinnerCells() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = getDefaultParameters(null, KEY.CELLS_PER_COLUMN, 1);
p = getDefaultParameters(p, KEY.MIN_THRESHOLD, 1);
p.apply(cn);
TemporalMemory.init(cn);
int[] previousActiveColumns = { 0, 1 };
Set<Cell> prevWinnerCells = cn.getCellSet(new int[] { 0, 1 });
int[] activeColumns = { 4 };
DistalDendrite matchingSegment = cn.createSegment(cn.getCell(4));
cn.createSynapse(matchingSegment, cn.getCell(0), 0.5);
ComputeCycle cc = tm.compute(cn, previousActiveColumns, true);
assertTrue(cc.winnerCells().equals(prevWinnerCells));
cc = tm.compute(cn, activeColumns, true);
List<Synapse> synapses = cn.getSynapses(matchingSegment);
assertEquals(2, synapses.size());
Collections.sort(synapses);
for(Synapse synapse : synapses) {
if(synapse.getPresynapticCell().getIndex() == 0) continue;
assertEquals(0.21, synapse.getPermanence(), 0.01);
assertEquals(1, synapse.getPresynapticCell().getIndex());
}
}
/**
* When a segment becomes active, grow synapses to previous winner cells.
*
* The number of grown synapses is calculated from the "matching segment"
* overlap, not the "active segment" overlap.
*/
@Test
public void testActiveSegmentGrowSynapsesAccordingToPotentialOverlap() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = getDefaultParameters(null, KEY.CELLS_PER_COLUMN, 1);
p = getDefaultParameters(p, KEY.MIN_THRESHOLD, 1);
p = getDefaultParameters(p, KEY.ACTIVATION_THRESHOLD, 2);
p = getDefaultParameters(p, KEY.MAX_NEW_SYNAPSE_COUNT, 4);
p.apply(cn);
TemporalMemory.init(cn);
// Use 1 cell per column so that we have easy control over the winner cells.
int[] previousActiveColumns = { 0, 1, 2, 3, 4 };
Set<Cell> prevWinnerCells = Arrays.asList(0, 1, 2, 3, 4)
.stream()
.map(i -> cn.getCell(i))
.collect(Collectors.toCollection(LinkedHashSet::new));
int[] activeColumns = { 5 };
DistalDendrite activeSegment = cn.createSegment(cn.getCell(5));
cn.createSynapse(activeSegment, cn.getCell(0), 0.5);
cn.createSynapse(activeSegment, cn.getCell(1), 0.5);
cn.createSynapse(activeSegment, cn.getCell(2), 0.2);
ComputeCycle cc = tm.compute(cn, previousActiveColumns, true);
assertEquals(prevWinnerCells, cc.winnerCells());
cc = tm.compute(cn, activeColumns, true);
Set<Cell> presynapticCells = cn.getSynapses(activeSegment).stream()
.map(s -> s.getPresynapticCell())
.collect(Collectors.toSet());
assertTrue(
presynapticCells.size() == 4 && (
presynapticCells.containsAll(Arrays.asList(cn.getCell(0), cn.getCell(1), cn.getCell(2), cn.getCell(3))) ||
presynapticCells.containsAll(Arrays.asList(cn.getCell(0), cn.getCell(1), cn.getCell(2), cn.getCell(4)))));
}
@Test
public void testDestroyWeakSynapseOnWrongPrediction() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = getDefaultParameters(null, KEY.INITIAL_PERMANENCE, 0.2);
p = getDefaultParameters(p, KEY.MAX_NEW_SYNAPSE_COUNT, 4);
p = getDefaultParameters(p, KEY.PREDICTED_SEGMENT_DECREMENT, 0.02);
p.apply(cn);
TemporalMemory.init(cn);
int[] previousActiveColumns = { 0 };
Cell[] previousActiveCells = { cn.getCell(0), cn.getCell(1), cn.getCell(2), cn.getCell(3) };
int[] activeColumns = { 2 };
Cell expectedActiveCell = cn.getCell(5);
DistalDendrite activeSegment = cn.createSegment(expectedActiveCell);
cn.createSynapse(activeSegment, previousActiveCells[0], 0.5);
cn.createSynapse(activeSegment, previousActiveCells[1], 0.5);
cn.createSynapse(activeSegment, previousActiveCells[2], 0.5);
// Weak Synapse
cn.createSynapse(activeSegment, previousActiveCells[3], 0.015);
tm.compute(cn, previousActiveColumns, true);
tm.compute(cn, activeColumns, true);
assertEquals(3, cn.numSynapses(activeSegment));
}
@Test
public void testDestroyWeakSynapseOnActiveReinforce() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = getDefaultParameters(null, KEY.INITIAL_PERMANENCE, 0.2);
p = getDefaultParameters(p, KEY.MAX_NEW_SYNAPSE_COUNT, 4);
p = getDefaultParameters(p, KEY.PREDICTED_SEGMENT_DECREMENT, 0.02);
p.apply(cn);
TemporalMemory.init(cn);
int[] previousActiveColumns = { 0 };
Cell[] previousActiveCells = { cn.getCell(0), cn.getCell(1), cn.getCell(2), cn.getCell(3) };
int[] activeColumns = { 2 };
Cell expectedActiveCell = cn.getCell(5);
DistalDendrite activeSegment = cn.createSegment(expectedActiveCell);
cn.createSynapse(activeSegment, previousActiveCells[0], 0.5);
cn.createSynapse(activeSegment, previousActiveCells[1], 0.5);
cn.createSynapse(activeSegment, previousActiveCells[2], 0.5);
// Weak Synapse
cn.createSynapse(activeSegment, previousActiveCells[3], 0.009);
tm.compute(cn, previousActiveColumns, true);
tm.compute(cn, activeColumns, true);
assertEquals(3, cn.numSynapses(activeSegment));
}
@Test
public void testRecycleWeakestSynapseToMakeRoomForNewSynapse() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = getDefaultParameters(null, KEY.CELLS_PER_COLUMN, 1);
p.set(KEY.COLUMN_DIMENSIONS, new int[] { 100 });
p = getDefaultParameters(p, KEY.MIN_THRESHOLD, 1);
p = getDefaultParameters(p, KEY.PERMANENCE_INCREMENT, 0.02);
p = getDefaultParameters(p, KEY.PERMANENCE_DECREMENT, 0.02);
p.set(KEY.MAX_SYNAPSES_PER_SEGMENT, 3);
p.apply(cn);
TemporalMemory.init(cn);
assertEquals(3, cn.getMaxSynapsesPerSegment());
int[] prevActiveColumns = { 0, 1, 2 };
Set<Cell> prevWinnerCells = cn.getCellSet(new int[] { 0, 1, 2 });
int[] activeColumns = { 4 };
DistalDendrite matchingSegment = cn.createSegment(cn.getCell(4));
cn.createSynapse(matchingSegment, cn.getCell(81), 0.6);
// Weakest Synapse
cn.createSynapse(matchingSegment, cn.getCell(0), 0.11);
ComputeCycle cc = tm.compute(cn, prevActiveColumns, true);
assertEquals(prevWinnerCells, cc.winnerCells);
tm.compute(cn, activeColumns, true);
List<Synapse> synapses = cn.getSynapses(matchingSegment);
assertEquals(3, synapses.size());
Set<Cell> presynapticCells = synapses.stream().map(s -> s.getPresynapticCell()).collect(Collectors.toSet());
assertFalse(presynapticCells.stream().mapToInt(cell -> cell.getIndex()).anyMatch(i -> i == 0));
}
@Test
public void testRecycleLeastRecentlyActiveSegmentToMakeRoomForNewSegment() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = getDefaultParameters(null, KEY.CELLS_PER_COLUMN, 1);
p = getDefaultParameters(p, KEY.INITIAL_PERMANENCE, 0.5);
p = getDefaultParameters(p, KEY.PERMANENCE_INCREMENT, 0.02);
p = getDefaultParameters(p, KEY.PERMANENCE_DECREMENT, 0.02);
p.set(KEY.MAX_SEGMENTS_PER_CELL, 2);
p.apply(cn);
TemporalMemory.init(cn);
int[] prevActiveColumns1 = { 0, 1, 2 };
int[] prevActiveColumns2 = { 3, 4, 5 };
int[] prevActiveColumns3 = { 6, 7, 8 };
int[] activeColumns = { 9 };
Cell cell9 = cn.getCell(9);
tm.compute(cn, prevActiveColumns1, true);
tm.compute(cn, activeColumns, true);
assertEquals(1, cn.getSegments(cell9).size());
DistalDendrite oldestSegment = cn.getSegments(cell9).get(0);
tm.reset(cn);
tm.compute(cn, prevActiveColumns2, true);
tm.compute(cn, activeColumns, true);
assertEquals(2, cn.getSegments(cell9).size());
Set<Cell> oldPresynaptic = cn.getSynapses(oldestSegment)
.stream()
.map(s -> s.getPresynapticCell())
.collect(Collectors.toSet());
tm.reset(cn);
tm.compute(cn, prevActiveColumns3, true);
tm.compute(cn, activeColumns, true);
assertEquals(2, cn.getSegments(cell9).size());
// Verify none of the segments are connected to the cells the old
// segment was connected to.
for(DistalDendrite segment : cn.getSegments(cell9)) {
Set<Cell> newPresynaptic = cn.getSynapses(segment)
.stream()
.map(s -> s.getPresynapticCell())
.collect(Collectors.toSet());
assertTrue(Collections.disjoint(oldPresynaptic, newPresynaptic));
}
}
@Test
public void testDestroySegmentsWithTooFewSynapsesToBeMatching() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = getDefaultParameters(null, KEY.INITIAL_PERMANENCE, .2);
p = getDefaultParameters(p, KEY.MAX_NEW_SYNAPSE_COUNT, 4);
p = getDefaultParameters(p, KEY.PREDICTED_SEGMENT_DECREMENT, 0.02);
p.apply(cn);
TemporalMemory.init(cn);
int[] prevActiveColumns = { 0 };
Cell[] prevActiveCells = { cn.getCell(0), cn.getCell(1), cn.getCell(2), cn.getCell(3) };
int[] activeColumns = { 2 };
Cell expectedActiveCell = cn.getCell(5);
DistalDendrite matchingSegment = cn.createSegment(cn.getCell(5));
cn.createSynapse(matchingSegment, prevActiveCells[0], .015);
cn.createSynapse(matchingSegment, prevActiveCells[1], .015);
cn.createSynapse(matchingSegment, prevActiveCells[2], .015);
cn.createSynapse(matchingSegment, prevActiveCells[3], .015);
tm.compute(cn, prevActiveColumns, true);
tm.compute(cn, activeColumns, true);
assertEquals(0, cn.numSegments(expectedActiveCell));
}
@Test
public void testPunishMatchingSegmentsInInactiveColumns() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = getDefaultParameters(null, KEY.MAX_NEW_SYNAPSE_COUNT, 4);
p = getDefaultParameters(p, KEY.INITIAL_PERMANENCE, 0.2);
p = getDefaultParameters(p, KEY.PREDICTED_SEGMENT_DECREMENT, 0.02);
p.apply(cn);
TemporalMemory.init(cn);
int[] prevActiveColumns = { 0 };
Cell[] prevActiveCells = { cn.getCell(0), cn.getCell(1), cn.getCell(2), cn.getCell(3) };
int[] activeColumns = { 1 };
Cell previousInactiveCell = cn.getCell(81);
DistalDendrite activeSegment = cn.createSegment(cn.getCell(42));
Synapse as1 = cn.createSynapse(activeSegment, prevActiveCells[0], .5);
Synapse as2 = cn.createSynapse(activeSegment, prevActiveCells[1], .5);
Synapse as3 = cn.createSynapse(activeSegment, prevActiveCells[2], .5);
Synapse is1 = cn.createSynapse(activeSegment, previousInactiveCell, .5);
DistalDendrite matchingSegment = cn.createSegment(cn.getCell(43));
Synapse as4 = cn.createSynapse(matchingSegment, prevActiveCells[0], .5);
Synapse as5 = cn.createSynapse(matchingSegment, prevActiveCells[1], .5);
Synapse is2 = cn.createSynapse(matchingSegment, previousInactiveCell, .5);
tm.compute(cn, prevActiveColumns, true);
tm.compute(cn, activeColumns, true);
assertEquals(0.48, as1.getPermanence(), 0.01);
assertEquals(0.48, as2.getPermanence(), 0.01);
assertEquals(0.48, as3.getPermanence(), 0.01);
assertEquals(0.48, as4.getPermanence(), 0.01);
assertEquals(0.48, as5.getPermanence(), 0.01);
assertEquals(0.50, is1.getPermanence(), 0.01);
assertEquals(0.50, is2.getPermanence(), 0.01);
}
@Test
public void testAddSegmentToCellWithFewestSegments() {
boolean grewOnCell1 = false;
boolean grewOnCell2 = false;
for(int seed = 0;seed < 100;seed++) {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = getDefaultParameters(null, KEY.MAX_NEW_SYNAPSE_COUNT, 4);
p = getDefaultParameters(p, KEY.PREDICTED_SEGMENT_DECREMENT, 0.02);
p = getDefaultParameters(p, KEY.SEED, seed);
p.apply(cn);
TemporalMemory.init(cn);
int[] prevActiveColumns = { 1, 2, 3, 4 };
Cell[] prevActiveCells = { cn.getCell(4), cn.getCell(5), cn.getCell(6), cn.getCell(7) };
int[] activeColumns = { 0 };
Cell[] nonMatchingCells = { cn.getCell(0), cn.getCell(3) };
Set<Cell> activeCells = cn.getCellSet(new int[] { 0, 1, 2, 3});
DistalDendrite segment1 = cn.createSegment(nonMatchingCells[0]);
cn.createSynapse(segment1, prevActiveCells[0], 0.5);
DistalDendrite segment2 = cn.createSegment(nonMatchingCells[1]);
cn.createSynapse(segment2, prevActiveCells[1], 0.5);
tm.compute(cn, prevActiveColumns, true);
ComputeCycle cc = tm.compute(cn, activeColumns, true);
assertTrue(cc.activeCells().equals(activeCells));
assertEquals(3, cn.numSegments());
assertEquals(1, cn.numSegments(cn.getCell(0)));
assertEquals(1, cn.numSegments(cn.getCell(3)));
assertEquals(1, cn.numSynapses(segment1));
assertEquals(1, cn.numSynapses(segment2));
List<DistalDendrite> segments = new ArrayList<>(cn.getSegments(cn.getCell(1)));
if(segments.size() == 0) {
List<DistalDendrite> segments2 = cn.getSegments(cn.getCell(2));
assertFalse(segments2.size() == 0);
grewOnCell2 = true;
segments.addAll(segments2);
} else {
grewOnCell1 = true;
}
assertEquals(1, segments.size());
List<Synapse> synapses = segments.get(0).getAllSynapses(cn);
assertEquals(4, synapses.size());
Set<Column> columnCheckList = cn.getColumnSet(prevActiveColumns);
for(Synapse synapse : synapses) {
assertEquals(0.2, synapse.getPermanence(), 0.01);
Column column = synapse.getPresynapticCell().getColumn();
assertTrue(columnCheckList.contains(column));
columnCheckList.remove(column);
}
assertEquals(0, columnCheckList.size());
}
assertTrue(grewOnCell1);
assertTrue(grewOnCell2);
}
@Test
public void testConnectionsNeverChangeWhenLearningDisabled() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = getDefaultParameters(null, KEY.MAX_NEW_SYNAPSE_COUNT, 4);
p = getDefaultParameters(p, KEY.PREDICTED_SEGMENT_DECREMENT, 0.02);
p = getDefaultParameters(p, KEY.INITIAL_PERMANENCE, 0.2);
p.apply(cn);
TemporalMemory.init(cn);
int[] prevActiveColumns = { 0 };
Cell[] prevActiveCells = { cn.getCell(0), cn.getCell(1), cn.getCell(2), cn.getCell(3) };
int[] activeColumns = { 1, 2 };
Cell prevInactiveCell = cn.getCell(81);
Cell expectedActiveCell = cn.getCell(4);
DistalDendrite correctActiveSegment = cn.createSegment(expectedActiveCell);
cn.createSynapse(correctActiveSegment, prevActiveCells[0], 0.5);
cn.createSynapse(correctActiveSegment, prevActiveCells[1], 0.5);
cn.createSynapse(correctActiveSegment, prevActiveCells[2], 0.5);
DistalDendrite wrongMatchingSegment = cn.createSegment(cn.getCell(43));
cn.createSynapse(wrongMatchingSegment, prevActiveCells[0], 0.5);
cn.createSynapse(wrongMatchingSegment, prevActiveCells[1], 0.5);
cn.createSynapse(wrongMatchingSegment, prevInactiveCell, 0.5);
Map<Cell, HashSet<Synapse>> synMapBefore = deepCopyPlain(cn.getReceptorSynapseMapping());
Map<Cell, List<DistalDendrite>> segMapBefore = deepCopyPlain(cn.getSegmentMapping());
tm.compute(cn, prevActiveColumns, false);
tm.compute(cn, activeColumns, false);
assertTrue(synMapBefore != cn.getReceptorSynapseMapping());
assertEquals(synMapBefore, cn.getReceptorSynapseMapping());
assertTrue(segMapBefore != cn.getSegmentMapping());
assertEquals(segMapBefore, cn.getSegmentMapping());
}
@Test
public void testLeastUsedCell() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = getDefaultParameters(null, KEY.COLUMN_DIMENSIONS, new int[] { 2 });
p = getDefaultParameters(p, KEY.CELLS_PER_COLUMN, 2);
p.apply(cn);
TemporalMemory.init(cn);
DistalDendrite dd = cn.createSegment(cn.getCell(0));
cn.createSynapse(dd, cn.getCell(3), 0.3);
for(int i = 0;i < 100;i++) {
assertEquals(1, tm.leastUsedCell(cn, cn.getColumn(0).getCells(), cn.getRandom()).getIndex());
}
}
@Test
public void testAdaptSegment() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = Parameters.getAllDefaultParameters();
p.apply(cn);
TemporalMemory.init(cn);
DistalDendrite dd = cn.createSegment(cn.getCell(0));
Synapse s1 = cn.createSynapse(dd, cn.getCell(23), 0.6);
Synapse s2 = cn.createSynapse(dd, cn.getCell(37), 0.4);
Synapse s3 = cn.createSynapse(dd, cn.getCell(477), 0.9);
tm.adaptSegment(cn, dd, cn.getCellSet(23, 37), cn.getPermanenceIncrement(), cn.getPermanenceDecrement());
assertEquals(0.7, s1.getPermanence(), 0.01);
assertEquals(0.5, s2.getPermanence(), 0.01);
assertEquals(0.8, s3.getPermanence(), 0.01);
}
@Test
public void testAdaptSegmentToMax() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = Parameters.getAllDefaultParameters();
p.apply(cn);
TemporalMemory.init(cn);
DistalDendrite dd = cn.createSegment(cn.getCell(0));
Synapse s1 = cn.createSynapse(dd, cn.getCell(23), 0.9);
tm.adaptSegment(cn, dd, cn.getCellSet(23), cn.getPermanenceIncrement(), cn.getPermanenceDecrement());
assertEquals(1.0, s1.getPermanence(), 0.1);
// Now permanence should be at max
tm.adaptSegment(cn, dd, cn.getCellSet(23), cn.getPermanenceIncrement(), cn.getPermanenceDecrement());
assertEquals(1.0, s1.getPermanence(), 0.1);
}
@Test
public void testAdaptSegmentToMin() {
TemporalMemory tm = new TemporalMemory();
Connections cn = new Connections();
Parameters p = Parameters.getAllDefaultParameters();
p.apply(cn);
TemporalMemory.init(cn);
DistalDendrite dd = cn.createSegment(cn.getCell(0));
Synapse s1 = cn.createSynapse(dd, cn.getCell(23), 0.1);
cn.createSynapse(dd, cn.getCell(1), 0.3);
tm.adaptSegment(cn, dd, cn.getCellSet(), cn.getPermanenceIncrement(), cn.getPermanenceDecrement());
assertFalse(cn.getSynapses(dd).contains(s1));
}
@Test
public void testNumberOfColumns() {
Connections cn = new Connections();
Parameters p = Parameters.getAllDefaultParameters();
p.set(KEY.COLUMN_DIMENSIONS, new int[] { 64, 64 });
p.set(KEY.CELLS_PER_COLUMN, 32);
p.apply(cn);
TemporalMemory.init(cn);
assertEquals(64 * 64, cn.getNumColumns());
}
@Test
public void testNumberOfCells() {
Connections cn = new Connections();
Parameters p = Parameters.getAllDefaultParameters();
p.set(KEY.COLUMN_DIMENSIONS, new int[] { 64, 64 });
p.set(KEY.CELLS_PER_COLUMN, 32);
p.apply(cn);
TemporalMemory.init(cn);
assertEquals(64 * 64 * 32, cn.getCells().length);
}
}
