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
})
class Model(object):
def __init__(self):
self.sensorEncoder = ScalarEncoder(n=512, w=21, minval=8.9, maxval=40,
clipInput=True, forced=True)
self.motorEncoder = ScalarEncoder(n=512, w=21, minval=-400, maxval=400,
clipInput=True, forced=True)
self.experimentRunner = SensorimotorExperimentRunner(
tmOverrides={
"columnDimensions": [512],
"maxNewSynapseCount": 21*2,
"minThreshold": 16*2,
"activationThreshold": 16*2
},
tpOverrides={
"columnDimensions": [512],
"numActiveColumnsPerInhArea": 20,
"poolingThreshUnpredicted": 0.5
}
)
def feed(self, sensorValue, motorValue, sequenceLabel=None):
sensorSDR = set(self.sensorEncoder.encode(sensorValue).nonzero()[0].tolist())
motorSDR = set((self.motorEncoder.encode(motorValue).nonzero()[0] +
self.sensorEncoder.n).tolist())
sensorimotorSDR = sensorSDR.union(motorSDR)
self.experimentRunner.feedTransition(sensorSDR, motorSDR, sensorimotorSDR,
tmLearn=True, tpLearn=True,
sequenceLabel=sequenceLabel)
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 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 __init__(self):
self.sensorEncoder = ScalarEncoder(n=512, w=21, minval=8.9, maxval=40,
clipInput=True, forced=True)
self.motorEncoder = ScalarEncoder(n=512, w=21, minval=-400, maxval=400,
clipInput=True, forced=True)
self.experimentRunner = SensorimotorExperimentRunner(
tmOverrides={
"columnDimensions": [512],
"maxNewSynapseCount": 21*2,
"minThreshold": 16*2,
"activationThreshold": 16*2
},
tpOverrides={
"columnDimensions": [512],
"numActiveColumnsPerInhArea": 20,
"poolingThreshUnpredicted": 0.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
class TemporalPoolerMonitorMixinTest(unittest.TestCase):
VERBOSITY = 1
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 testGetConfusionMetrics(self):
# Train TM
sequences = self.experimentRunner.generateSequences(20, self.agents)
self.experimentRunner.feedLayers(sequences,
tmLearn=True,
tpLearn=False,
verbosity=self.VERBOSITY)
self._printInformation()
self.assertEqual(
self.experimentRunner.tp.mmGetMetricStabilityConfusion().min, 0)
self.assertEqual(
self.experimentRunner.tp.mmGetMetricStabilityConfusion().max, 20)
self.assertTrue(
self.experimentRunner.tp.mmGetMetricStabilityConfusion().mean > 0)
self.assertEqual(
self.experimentRunner.tp.mmGetMetricDistinctnessConfusion().min, 0)
self.assertTrue(
self.experimentRunner.tp.mmGetMetricDistinctnessConfusion().max < 5
)
self.assertTrue(self.experimentRunner.tp.
mmGetMetricDistinctnessConfusion().mean > 0)
# Train TP
sequences = self.experimentRunner.generateSequences(10, self.agents)
self.experimentRunner.feedLayers(sequences,
tmLearn=False,
tpLearn=True,
verbosity=self.VERBOSITY)
self._printInformation()
self.assertEqual(
self.experimentRunner.tp.mmGetMetricStabilityConfusion().sum, 0)
# Test
sequences = self.experimentRunner.generateSequences(5,
self.agents,
numSequences=2)
self.experimentRunner.feedLayers(sequences,
tmLearn=False,
tpLearn=False,
verbosity=self.VERBOSITY)
self._printInformation()
self.assertTrue(
self.experimentRunner.tp.mmGetMetricStabilityConfusion().max < 5)
self.assertTrue(
self.experimentRunner.tp.mmGetMetricDistinctnessConfusion().max < 5
)
def _printInformation(self):
if self.VERBOSITY > 1:
print "Overlap"
print "============"
print
print self.experimentRunner.tp.mmPrettyPrintDataOverlap()
print
print "Metrics"
print "============"
print
print self.experimentRunner.tp.mmPrettyPrintMetrics(
self.experimentRunner.tp.mmGetDefaultMetrics())
agents = [
RandomOneDAgent(OneDWorld(universe, range(nElements), 4),
possibleMotorValues=(-1,1), seed=23),
]
l3NumColumns = 512
l3NumActiveColumnsPerInhArea = 20
############################################################
# Initialize the experiment runner with relevant parameters
smer = SensorimotorExperimentRunner(
tmOverrides={
"columnDimensions": [nElements*wEncoders],
"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(40, agents, verbosity=1)
smer.feedLayers(sequences, tmLearn=True, verbosity=1)
# Check if TM learning went ok
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
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],
"minThreshold": wTotal,
"activationThreshold": wTotal,
"maxNewSynapseCount": wTotal
},
tpOverrides={
"columnDimensions": [universe.nSensor],
"numActiveColumnsPerInhArea": universe.wSensor,
"potentialPct": 0.9,
"initConnectedPct": 0.5
}
)
print "Done setting up experiment.\n"
exhaustiveAgents = []
randomAgents = []
completeSequenceLength = numElements ** 2
for world in xrange(numWorlds):
elements = range(world * numElements, world * numElements + numElements)
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,
class TemporalPoolerMonitorMixinTest(unittest.TestCase):
VERBOSITY = 1
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 testGetConfusionMetrics(self):
# Train TM
sequences = self.experimentRunner.generateSequences(20, self.agents)
self.experimentRunner.feedLayers(sequences, tmLearn=True, tpLearn=False, verbosity=self.VERBOSITY)
self._printInformation()
self.assertEqual(self.experimentRunner.tp.mmGetMetricStabilityConfusion().min, 0)
self.assertEqual(self.experimentRunner.tp.mmGetMetricStabilityConfusion().max, 20)
self.assertTrue(self.experimentRunner.tp.mmGetMetricStabilityConfusion().mean > 0)
self.assertEqual(self.experimentRunner.tp.mmGetMetricDistinctnessConfusion().min, 0)
self.assertTrue(self.experimentRunner.tp.mmGetMetricDistinctnessConfusion().max < 5)
self.assertTrue(self.experimentRunner.tp.mmGetMetricDistinctnessConfusion().mean > 0)
# Train TP
sequences = self.experimentRunner.generateSequences(10, self.agents)
self.experimentRunner.feedLayers(sequences, tmLearn=False, tpLearn=True, verbosity=self.VERBOSITY)
self._printInformation()
self.assertEqual(self.experimentRunner.tp.mmGetMetricStabilityConfusion().sum, 0)
# Test
sequences = self.experimentRunner.generateSequences(5, self.agents, numSequences=2)
self.experimentRunner.feedLayers(sequences, tmLearn=False, tpLearn=False, verbosity=self.VERBOSITY)
self._printInformation()
self.assertTrue(self.experimentRunner.tp.mmGetMetricStabilityConfusion().max < 5)
self.assertTrue(self.experimentRunner.tp.mmGetMetricDistinctnessConfusion().max < 5)
def _printInformation(self):
if self.VERBOSITY > 1:
print "Overlap"
print "============"
print
print self.experimentRunner.tp.mmPrettyPrintDataOverlap()
print
print "Metrics"
print "============"
print
print self.experimentRunner.tp.mmPrettyPrintMetrics(self.experimentRunner.tp.mmGetDefaultMetrics())
class TemporalPoolerMonitorMixinTest(unittest.TestCase):
VERBOSITY = 1
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 testGetConfusionMetrics(self):
# Train
sequences = self.experimentRunner.generateSequences(40, self.agents)
self.experimentRunner.feedLayers(sequences,
tmLearn=True,
tpLearn=True,
verbosity=self.VERBOSITY)
self._printInformation()
self.assertEqual(
self.experimentRunner.tp.mmGetMetricStabilityConfusion().min, 0)
self.assertEqual(
self.experimentRunner.tp.mmGetMetricStabilityConfusion().max, 40)
self.assertTrue(
self.experimentRunner.tp.mmGetMetricStabilityConfusion().mean > 0)
self.assertTrue(self.experimentRunner.tp.
mmGetMetricDistinctnessConfusion().min > 20)
self.assertTrue(self.experimentRunner.tp.
mmGetMetricDistinctnessConfusion().max > 20)
self.assertTrue(self.experimentRunner.tp.
mmGetMetricDistinctnessConfusion().mean > 20)
# Test
sequences = self.experimentRunner.generateSequences(10, self.agents)
self.experimentRunner.feedLayers(sequences,
tmLearn=False,
tpLearn=False,
verbosity=self.VERBOSITY)
self._printInformation()
self.assertEqual(
self.experimentRunner.tp.mmGetMetricStabilityConfusion().sum, 0)
self.assertTrue(self.experimentRunner.tp.
mmGetMetricDistinctnessConfusion().sum < 12)
def _printInformation(self):
if self.VERBOSITY > 1:
print "Stability"
print "============"
print
print self.experimentRunner.tp.mmPrettyPrintDataStabilityConfusion(
)
print
print "Distinctness"
print "============"
print
print self.experimentRunner.tp.mmPrettyPrintDataDistinctnessConfusion(
)
print
print "Metrics"
print "============"
print
print self.experimentRunner.tp.mmPrettyPrintMetrics(
self.experimentRunner.tp.mmGetDefaultMetrics())
