def testDecodeSensorValue(self):
universe = OneDUniverse()
for i in range(universe.numDecodedElements):
self.assertIsNotNone(universe.decodeSensorValue(i))
self.assertRaises(IndexError,
universe.decodeSensorValue, universe.numDecodedElements)
def testDecodeSensorValue(self):
universe = OneDUniverse()
for i in range(universe.numDecodedElements):
self.assertIsNotNone(universe.decodeSensorValue(i))
self.assertRaises(IndexError,
universe.decodeSensorValue, universe.numDecodedElements)
def testEncodeSensorValue(self):
universe = OneDUniverse(debugSensor=True,
nSensor=105, wSensor=5, nMotor=105, wMotor=5)
self.assertEqual(universe.encodeSensorValue(0), set(xrange(0, 5)))
self.assertEqual(universe.encodeSensorValue(19), set(xrange(95, 100)))
self.assertEqual(universe.encodeSensorValue(20), set(xrange(100, 105)))
universe = OneDUniverse(debugSensor=False,
nSensor=105, wSensor=5, nMotor=105, wMotor=5)
self.assertNotEqual(universe.encodeSensorValue(0), set(xrange(0, 5)))
def testSingleWorldBasic(self):
"""
Test Sensorimotor Temporal Memory learning in a single world.
Patterns are represented as complete SDRs. No patterns are repeated.
Prediction should be perfect.
"""
self._init()
universe = OneDUniverse(debugSensor=True,
debugMotor=True,
nSensor=100,
wSensor=10,
nMotor=70,
wMotor=10)
world = OneDWorld(universe, [0, 1, 2, 3], 2)
agent = RandomOneDAgent(world, possibleMotorValues=set(xrange(-3, 4)))
sequence = self._generateSensorimotorSequences(100, [agent])
self._feedTM(sequence)
sequence = self._generateSensorimotorSequences(100, [agent])
stats = self._testTM(sequence)
self._assertAllActiveWerePredicted(stats, universe)
self._assertAllInactiveWereUnpredicted(stats)
self._assertSequencesOnePredictedActiveCellPerColumn(stats)
def setUp(self):
# Initialize the universe, worlds, and agents
nElements = 4
nWorlds = 3
n = 512
w = 20
universe = OneDUniverse(debugSensor=True,
debugMotor=True,
nSensor=n,
wSensor=w,
nMotor=n,
wMotor=w)
self.agents = [
RandomOneDAgent(OneDWorld(
universe, range(nElements * world, nElements * (world + 1))),
0,
possibleMotorValues=(-1, 1),
seed=23) for world in xrange(nWorlds)
]
self.experimentRunner = SensorimotorExperimentRunner(
tmOverrides={
"columnDimensions": [n],
"minThreshold": w * 2,
"maxNewSynapseCount": w * 2,
"activationThreshold": w * 2,
"seed": 42
},
tpOverrides={
"columnDimensions": [n],
"numActiveColumnsPerInhArea": w,
"seed": 42
})
def setUp(self):
# Initialize the universe, worlds, and agents
nElements = 5
wEncoders = 7
universe = OneDUniverse(debugSensor=True,
debugMotor=True,
nSensor=nElements * wEncoders,
wSensor=wEncoders,
nMotor=wEncoders * 7,
wMotor=wEncoders)
self.agents = [
RandomOneDAgent(OneDWorld(universe, range(nElements)),
4,
possibleMotorValues=(-1, 1),
seed=23),
RandomOneDAgent(OneDWorld(universe,
list(reversed(range(nElements)))),
4,
possibleMotorValues=(-1, 1),
seed=23)
]
self.experimentRunner = SensorimotorExperimentRunner(
tmOverrides={
"columnDimensions": [nElements * wEncoders],
"minThreshold": wEncoders * 2,
"maxNewSynapseCount": wEncoders * 2,
"activationThreshold": wEncoders * 2
},
tpOverrides={
"columnDimensions": [512],
"numActiveColumnsPerInhArea": 20
})
def testMultipleWorldsSharedPatterns(self):
"""
Test Sensorimotor Temporal Memory learning in multiple separate worlds.
Patterns are represented as complete SDRs. Patterns are shared between
worlds.
All active columns should have been predicted.
"""
self._init()
universe = OneDUniverse(debugMotor=True,
nSensor=100,
wSensor=10,
nMotor=70,
wMotor=10)
agents = []
numWorlds = 5
for i in xrange(numWorlds):
patterns = range(4)
self._random.shuffle(patterns)
world = OneDWorld(universe, patterns, 2)
agent = RandomOneDAgent(world,
possibleMotorValues=set(xrange(-3, 4)))
agents.append(agent)
sequence = self._generateSensorimotorSequences(150, agents)
self._feedTM(sequence)
sequence = self._generateSensorimotorSequences(100, agents)
stats = self._testTM(sequence)
self._assertAllActiveWerePredicted(stats, universe)
self.assertTrue(0 < stats.predictedInactiveColumns.average < 10)
def testMultipleWorldsBasic(self):
"""
Test Sensorimotor Temporal Memory learning in multiple separate worlds.
Patterns are represented as complete SDRs. No patterns are repeated.
Prediction should be perfect.
"""
self._init()
universe = OneDUniverse(debugMotor=True,
nSensor=100,
wSensor=10,
nMotor=70,
wMotor=10)
agents = []
numWorlds = 5
sequenceLength = 4
for i in xrange(numWorlds):
start = i * sequenceLength
patterns = range(start, start + sequenceLength)
world = OneDWorld(universe, patterns, 2)
agent = RandomOneDAgent(world,
possibleMotorValues=set(xrange(-3, 4)))
agents.append(agent)
sequence = self._generateSensorimotorSequences(150, agents)
self._feedTM(sequence)
sequence = self._generateSensorimotorSequences(100, agents)
stats = self._testTM(sequence)
self._assertAllActiveWerePredicted(stats, universe)
self._assertAllInactiveWereUnpredicted(stats)
self._assertSequencesOnePredictedActiveCellPerColumn(stats)
def testSingleWorldOneBitPerPattern(self):
"""
Test Sensorimotor Temporal Memory learning in a single world.
Patterns (sensor and motor) are represented with one active bit per pattern.
"""
self._init({
"columnDimensions": [4],
"minThreshold": 2,
"activationThreshold": 2
})
universe = OneDUniverse(debugSensor=True,
debugMotor=True,
nSensor=4,
wSensor=1,
nMotor=3,
wMotor=1)
world = OneDWorld(universe, [0, 1, 2, 3], 2)
agent = RandomOneDAgent(world, possibleMotorValues=set(xrange(-1, 2)))
sequence = self._generateSensorimotorSequences(100, [agent])
self._feedTM(sequence)
sequence = self._generateSensorimotorSequences(20, [agent])
stats = self._testTM(sequence)
self._assertAllActiveWerePredicted(stats, universe)
self._assertAllInactiveWereUnpredicted(stats)
self._assertSequencesOnePredictedActiveCellPerColumn(stats)
def testEncodeMotorValue(self):
universe = OneDUniverse(debugMotor=True,
nSensor=105, wSensor=5, nMotor=48*21, wMotor=48)
self.assertEqual(universe.encodeMotorValue(-10), set(xrange(0, 48)))
self.assertEqual(universe.encodeMotorValue(0), set(xrange(480, 528)))
self.assertEqual(universe.encodeMotorValue(10), set(xrange(960, 1008)))
universe = OneDUniverse(debugMotor=False,
nSensor=105, wSensor=5, nMotor=48*21, wMotor=48)
self.assertNotEqual(universe.encodeMotorValue(-10), set(xrange(0, 48)))
def testEncodeSensorValue(self):
universe = OneDUniverse(debugSensor=True,
nSensor=105, wSensor=5, nMotor=105, wMotor=5)
self.assertEqual(universe.encodeSensorValue(0), set(xrange(0, 5)))
self.assertEqual(universe.encodeSensorValue(19), set(xrange(95, 100)))
self.assertEqual(universe.encodeSensorValue(20), set(xrange(100, 105)))
universe = OneDUniverse(debugSensor=False,
nSensor=105, wSensor=5, nMotor=105, wMotor=5)
self.assertNotEqual(universe.encodeSensorValue(0), set(xrange(0, 5)))
def testChooseMotorValue(self):
universe = OneDUniverse(nSensor=100, wSensor=5, nMotor=105, wMotor=5)
world = OneDWorld(universe, [2, 0, 5, 15, 10], 2)
agent = RandomOneDAgent(world,
possibleMotorValues=set(xrange(-10, 10)))
for _ in range(100):
motorValue = agent.chooseMotorValue()
self.assertTrue(-2 <= motorValue <= 2) # bounded by size of world
world.move(-2)
for _ in range(100):
motorValue = agent.chooseMotorValue()
self.assertTrue(0 <= motorValue <= 4) # bounded by size of world
def testEncodeMotorValue(self):
universe = OneDUniverse(debugMotor=True,
nSensor=105, wSensor=5, nMotor=48*21, wMotor=48)
self.assertEqual(universe.encodeMotorValue(-10), set(xrange(0, 48)))
self.assertEqual(universe.encodeMotorValue(0), set(xrange(480, 528)))
self.assertEqual(universe.encodeMotorValue(10), set(xrange(960, 1008)))
universe = OneDUniverse(debugMotor=False,
nSensor=105, wSensor=5, nMotor=48*21, wMotor=48)
self.assertNotEqual(universe.encodeMotorValue(-10), set(xrange(0, 48)))
def testDistanceToBoundaries(self):
universe = OneDUniverse(debugSensor=True,
debugMotor=True,
nSensor=100,
wSensor=5,
nMotor=25,
wMotor=5)
world = OneDWorld(universe, [2, 0, 5, 15, 10], 2)
self.assertEqual(world.distanceToBoundaries(), (2, 2))
world.move(-2)
self.assertEqual(world.distanceToBoundaries(), (0, 4))
world.move(2)
world.move(2)
self.assertEqual(world.distanceToBoundaries(), (4, 0))
def testChooseMotorValueStartAt2(self):
numElements = 5
universe = OneDUniverse(nSensor=100, wSensor=5, nMotor=100, wMotor=5)
world = OneDWorld(universe, range(numElements))
agent = ExhaustiveOneDAgent(world, 2)
motorValues = []
for _ in range(numElements**2):
motorValue = agent.chooseMotorValue()
agent.move(motorValue)
motorValues.append(motorValue)
self.assertEqual(motorValues, [
-2, 2, -1, 1, 1, -1, 2, -2, -2, 1, -1, 3, -3, 4, -4, 1, 2, -2, 3,
-3, 2, 1, -1, 1, -2
])
def testGenerateSensorimotorSequence(self):
universe = OneDUniverse(nSensor=100, wSensor=5, nMotor=105, wMotor=5)
world = OneDWorld(universe, [2, 0, 5, 15, 10], 2)
agent = RandomOneDAgent(world,
possibleMotorValues=set(xrange(-10, 10)))
sensorSequence, motorSequence, sensorimotorSequence = (
agent.generateSensorimotorSequence(20))
self.assertEqual(len(sensorSequence), 20)
self.assertEqual(len(motorSequence), 20)
self.assertEqual(len(sensorimotorSequence), 20)
# Ensure each encoded pattern has the correct number of ON bits
for i in range(20):
self.assertEqual(len(sensorSequence[i]), 5)
self.assertEqual(len(motorSequence[i]), 5)
self.assertEqual(len(sensorimotorSequence[i]), 10)
def testMultipleWorldsSharedPatternsNoSharedSubsequencesWithSelfMovement(
self):
"""Test Sensorimotor Temporal Memory learning in multiple separate worlds.
Patterns are represented as complete SDRs. Patterns are shared between
worlds. Worlds have no shared subsequences. Allows movements with value 0
(self-movements).
All active columns should have been predicted.
All inactive columns should have been unpredicted.
Patterns in different worlds should have different cell representations.
"""
self._init()
universe = OneDUniverse(debugSensor=True,
debugMotor=True,
nSensor=100,
wSensor=10,
nMotor=70,
wMotor=10)
agents = []
patterns = range(4)
for _ in xrange(2):
world = OneDWorld(universe, patterns)
agent = RandomOneDAgent(world,
2,
possibleMotorValues=set(xrange(-3, 4)))
agents.append(agent)
patterns = list(patterns) # copy
patterns.reverse()
sequence = self._generateSensorimotorSequences(150, agents)
self._feedTM(sequence)
sequence = self._generateSensorimotorSequences(100, agents)
self._testTM(sequence)
self._assertAllActiveWerePredicted(universe)
predictedInactiveColumnsMetric = self.tm.mmGetMetricFromTrace(
self.tm.mmGetTracePredictedInactiveColumns())
# Note: There will be extra predictions because transitions are shared
# between the worlds (the self-movements)
self.assertTrue(0 < predictedInactiveColumnsMetric.mean < 5)
self._assertSequencesOnePredictedActiveCellPerColumn()
self._assertOneSequencePerPredictedActiveCell()
def testMotion(self):
universe = OneDUniverse(debugSensor=True,
debugMotor=True,
nSensor=100,
wSensor=5,
nMotor=100,
wMotor=20)
world = OneDWorld(universe, [2, 0, 5, 15, 10], 2)
self.assertEqual(set(xrange(25, 30)), world.sense())
self.assertEqual(world.move(1), set(xrange(60, 80)))
self.assertEqual(set(xrange(75, 80)), world.sense())
self.assertEqual(world.move(-2), set(xrange(0, 20)))
self.assertEqual(set(xrange(0, 5)), world.sense())
self.assertEqual(world.move(0), set(xrange(40, 60)))
self.assertEqual(set(xrange(0, 5)), world.sense())
def testMultipleWorldsSharedPatternsNoSharedSubsequences(self):
"""
Test Sensorimotor Temporal Memory learning in multiple separate worlds.
Patterns are represented as complete SDRs. Patterns are shared between
worlds. Worlds have no shared subsequences.
All active columns should have been predicted.
Patterns in different worlds should have different cell representations
"""
self._init()
universe = OneDUniverse(debugSensor=True,
debugMotor=True,
nSensor=100,
wSensor=10,
nMotor=70,
wMotor=10)
agents = []
patterns = range(4)
for _ in xrange(2):
world = OneDWorld(universe, patterns, 2)
agent = RandomOneDAgent(world,
possibleMotorValues=set(
[-3, -2, -1, 1, 2, 3]))
agents.append(agent)
patterns = list(patterns) # copy
patterns.reverse()
sequence = self._generateSensorimotorSequences(150, agents)
self._feedTM(sequence)
sequence = self._generateSensorimotorSequences(100, agents)
stats = self._testTM(sequence)
self._assertAllActiveWerePredicted(stats, universe)
self.assertTrue(0 < stats.predictedInactiveColumns.average < 5)
self._assertSequencesOnePredictedActiveCellPerColumn(stats)
self._assertOneSequencePerPredictedActiveCell(stats)
def setupExperiment(n, w, numElements, numWorlds, tmParams, tpParams):
print "Setting up experiment..."
universe = OneDUniverse(nSensor=n, wSensor=w,
nMotor=n, wMotor=w)
runner = SensorimotorExperimentRunner(tmOverrides=tmParams,
tpOverrides=tpParams,
seed=RANDOM_SEED)
exhaustiveAgents = []
randomAgents = []
for world in xrange(numWorlds):
elements = range(world * numElements, world * numElements + numElements)
# agent = ExhaustiveOneDAgent(OneDWorld(universe, elements), 0)
# exhaustiveAgents.append(agent)
possibleMotorValues = range(-numElements, numElements + 1)
possibleMotorValues.remove(0)
agent = RandomOneDAgent(OneDWorld(universe, elements), numElements / 2,
possibleMotorValues=possibleMotorValues,
seed=RANDOM_SEED)
randomAgents.append(agent)
print "Done setting up experiment."
print
return runner, exhaustiveAgents, randomAgents
def testMultipleWorldsSharedPatterns(self):
"""Test Sensorimotor Temporal Memory learning in multiple separate worlds.
Patterns are represented as complete SDRs. Patterns are shared between
worlds.
All active columns should have been predicted.
"""
self._init()
universe = OneDUniverse(debugSensor=True,
debugMotor=True,
nSensor=100,
wSensor=10,
nMotor=70,
wMotor=10)
agents = []
patternSets = [[3, 2, 1, 0], [0, 2, 1, 3], [1, 2, 0, 3], [3, 0, 2, 1],
[1, 0, 2, 3]]
for patterns in patternSets:
world = OneDWorld(universe, patterns)
agent = RandomOneDAgent(world,
2,
possibleMotorValues=set(
[-3, -2, -1, 1, 2, 3]))
agents.append(agent)
sequence = self._generateSensorimotorSequences(150, agents)
self._feedTM(sequence)
sequence = self._generateSensorimotorSequences(100, agents)
self._testTM(sequence)
self._assertAllActiveWerePredicted(universe)
predictedInactiveColumnsMetric = self.tm.mmGetMetricFromTrace(
self.tm.mmGetTracePredictedInactiveColumns())
self.assertTrue(0 < predictedInactiveColumnsMetric.mean < 5)
from sensorimotor.random_one_d_agent import RandomOneDAgent
from sensorimotor.sensorimotor_experiment_runner import (
SensorimotorExperimentRunner)
print """
This program runs sensorimotor inference and pooling with several static worlds.
"""
############################################################
# Initialize the universe, worlds, and agents
nElements = 20
wEncoders = 21
universe = OneDUniverse(debugSensor=False,
debugMotor=False,
nSensor=512,
wSensor=wEncoders,
nMotor=wEncoders * 7,
wMotor=wEncoders)
# Initialize a bunch of worlds, each with at most 8 elements
agents = [
RandomOneDAgent(OneDWorld(universe, range(8), 4),
possibleMotorValues=(-2, -1, 1, 2),
seed=23),
RandomOneDAgent(OneDWorld(universe, range(8 - 1, -1, -1), 4),
possibleMotorValues=(-2, -1, 1, 2),
seed=42),
RandomOneDAgent(OneDWorld(universe, range(0, 16, 2), 4),
possibleMotorValues=(-2, -1, 1, 2),
seed=10),
RandomOneDAgent(OneDWorld(universe, range(0, 15, 3), 2),
if verbosity >= 2:
print tm.prettyPrintHistory(verbosity=verbosity)
print
if learn and verbosity >= 3:
print tm.mmPrettyPrintConnections()
return tm.getStatistics()
# Initialize the universe, worlds, and agents
nElements = 10
wEncoders = 7
universe = OneDUniverse(debugSensor=True,
debugMotor=True,
nSensor=nElements * wEncoders,
wSensor=wEncoders,
nMotor=wEncoders * 7,
wMotor=wEncoders)
agents = [
RandomOneDAgent(OneDWorld(universe, range(nElements)),
4,
possibleMotorValues=(-1, 1),
seed=23),
RandomOneDAgent(OneDWorld(universe, range(nElements - 1, -1, -1)),
4,
possibleMotorValues=(-1, 1),
seed=42),
RandomOneDAgent(OneDWorld(universe, range(0, nElements, 2)),
4,
possibleMotorValues=(-1, 1),
seed=10),
def run(numWorlds, numElements, outputDir, params=DEFAULTS):
# Extract params
n = params["n"]
w = params["w"]
tmParams = params["tmParams"]
tpParams = params["tpParams"]
# Initialize output
if not os.path.exists(outputDir):
os.makedirs(outputDir)
csvFilePath = os.path.join(outputDir,
"{0}x{1}.csv".format(numWorlds, numElements))
# Initialize experiment
start = time.time()
universe = OneDUniverse(nSensor=n, wSensor=w, nMotor=n, wMotor=w)
# Run the experiment
with open(csvFilePath, 'wb') as csvFile:
csvWriter = csv.writer(csvFile)
print(
"Experiment parameters: "
"(# worlds = {0}, # elements = {1}, n = {2}, w = {3})".format(
numWorlds, numElements, n, w))
print "Temporal memory parameters: {0}".format(tmParams)
print "Temporal pooler parameters: {0}".format(tpParams)
print
print "Setting up experiment..."
runner = SensorimotorExperimentRunner(tmOverrides=tmParams,
tpOverrides=tpParams)
print "Done setting up experiment."
print
exhaustiveAgents = []
randomAgents = []
completeSequenceLength = numElements**2
for world in xrange(numWorlds):
elements = range(world * numElements,
world * numElements + numElements)
exhaustiveAgents.append(
ExhaustiveOneDAgent(OneDWorld(universe, elements), 0))
possibleMotorValues = range(-numElements, numElements + 1)
possibleMotorValues.remove(0)
randomAgents.append(
RandomOneDAgent(OneDWorld(universe, elements),
numElements / 2,
possibleMotorValues=possibleMotorValues))
print "Training (worlds: {0}, elements: {1})...".format(
numWorlds, numElements)
print
print "Training temporal memory..."
sequences = runner.generateSequences(completeSequenceLength * 2,
exhaustiveAgents,
verbosity=VERBOSITY)
runner.feedLayers(sequences,
tmLearn=True,
tpLearn=False,
verbosity=VERBOSITY,
showProgressInterval=SHOW_PROGRESS_INTERVAL)
print
print MonitorMixinBase.mmPrettyPrintMetrics(
runner.tp.mmGetDefaultMetrics() + runner.tm.mmGetDefaultMetrics())
print
print "Training temporal pooler..."
sequences = runner.generateSequences(completeSequenceLength * 1,
exhaustiveAgents,
verbosity=VERBOSITY)
runner.feedLayers(sequences,
tmLearn=False,
tpLearn=True,
verbosity=VERBOSITY,
showProgressInterval=SHOW_PROGRESS_INTERVAL)
print
print "Done training."
print
print MonitorMixinBase.mmPrettyPrintMetrics(
runner.tp.mmGetDefaultMetrics() + runner.tm.mmGetDefaultMetrics())
print
if PLOT >= 1:
runner.tp.mmGetPlotConnectionsPerColumn(
title="worlds: {0}, elements: {1}".format(
numWorlds, numElements))
print "Testing (worlds: {0}, elements: {1})...".format(
numWorlds, numElements)
sequences = runner.generateSequences(completeSequenceLength / 4,
randomAgents,
verbosity=VERBOSITY,
numSequences=4)
runner.feedLayers(sequences,
tmLearn=False,
tpLearn=False,
verbosity=VERBOSITY,
showProgressInterval=SHOW_PROGRESS_INTERVAL)
print "Done testing.\n"
if VERBOSITY >= 2:
print "Overlap:"
print
print runner.tp.mmPrettyPrintDataOverlap()
print
print MonitorMixinBase.mmPrettyPrintMetrics(
runner.tp.mmGetDefaultMetrics() + runner.tm.mmGetDefaultMetrics())
print
elapsed = int(time.time() - start)
print "Total time: {0:2} seconds.".format(elapsed)
header = ["# worlds", "# elements", "duration"]
row = [numWorlds, numElements, elapsed]
for metric in (runner.tp.mmGetDefaultMetrics() +
runner.tm.mmGetDefaultMetrics()):
header += [
"{0} ({1})".format(metric.prettyPrintTitle(), x)
for x in ["min", "max", "sum", "mean", "stddev"]
]
row += [
metric.min, metric.max, metric.sum, metric.mean,
metric.standardDeviation
]
csvWriter.writerow(header)
csvWriter.writerow(row)
csvFile.flush()
if PLOT >= 1:
raw_input("Press any key to exit...")
"tp_stability_sum", "tp_stability_mean", "tp_stability_stddev",
"tp_distinctness_min", "tp_distinctness_max", "tp_distinctness_sum",
"tp_distinctness_mean", "tp_distinctness_stddev"
]
OUTPUT_FILE = ("memorization_capacity_test_results.csv"
if len(sys.argv) <= 1 else sys.argv[1])
# Set constants
numWorldsRange = range(2, 100, 5)
numElementsRange = range(2, 100, 5)
VERBOSITY = 0
SHOW_PROGRESS_INTERVAL = 10
# Initialize experiment
universe = OneDUniverse(nSensor=512, wSensor=20, nMotor=512, wMotor=20)
wTotal = universe.wSensor + universe.wMotor
# Run the experiment
with open(OUTPUT_FILE, 'wb') as outFile:
csvWriter = csv.writer(outFile)
headerWritten = False
combinations = sorted(
product(numWorldsRange, numElementsRange),
key=lambda x: x[0] * x[1]) # sorted by total # of elements
for numWorlds, numElements in combinations:
print "Setting up a new experiment..."
runner = SensorimotorExperimentRunner(tmOverrides={
"columnDimensions": [universe.nSensor],
