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)
agent = RandomOneDAgent(world,
2,
possibleMotorValues=set(xrange(-3, 4)))
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 < 10)
def testMultipleWorldsSharedPatternsWithSelfMovement(self):
"""Test Sensorimotor Temporal Memory learning in multiple separate worlds.
Patterns are represented as complete SDRs. Patterns are shared between
worlds. Allows movements with value 0 (self-movements).
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(xrange(-3, 4)))
agents.append(agent)
sequence = self._generateSensorimotorSequences(250, 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)
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 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...")
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),
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),
"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],
