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 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...")
possibleMotorValues=(-2, -1, 1, 2),
seed=5),
]
l3NumColumns = 512
l3NumActiveColumnsPerInhArea = 20
############################################################
# Initialize the experiment runner with relevant parameters
print "Initializing experiment runner"
smer = SensorimotorExperimentRunner(tmOverrides={
"columnDimensions": [universe.nSensor],
"minThreshold": wEncoders * 2,
"maxNewSynapseCount": wEncoders * 2,
"activationThreshold": wEncoders * 2
},
tpOverrides={
"columnDimensions": [l3NumColumns],
"numActiveColumnsPerInhArea":
l3NumActiveColumnsPerInhArea,
})
############################################################
# Temporal memory training
print "Training TemporalMemory on sequences"
sequences = smer.generateSequences(500, agents, verbosity=0)
smer.feedLayers(sequences, tmLearn=True, verbosity=0)
# Check if TM learning went ok
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],
"minThreshold":
wTotal,
"activationThreshold":
wTotal,
"maxNewSynapseCount":
wTotal
},
tpOverrides={
"columnDimensions":
[universe.nSensor],
"numActiveColumnsPerInhArea":
universe.wSensor
})
print "Done setting up experiment.\n"
exhaustiveAgents = []
randomAgents = []
completeSequenceLength = numElements**2
for world in xrange(numWorlds):
elements = range(world * numElements,
