def run(params, paramDir, outputDir, plotVerbosity=0, consoleVerbosity=0):
"""
Runs the Union Pooler capacity experiment.
:param params: A dict containing the following experiment parameters:
patternDimensionality - Dimensionality of sequence patterns
patternCardinality - Cardinality (# ON bits) of sequence patterns
sequenceLength - Length of sequences shown to network
sequenceCount - Number of unique sequences used
trainingPasses - Number of times Temporal Memory is trained on each
sequence
temporalMemoryParams - A dict of Temporal Memory parameter overrides
unionPoolerParams - A dict of Union Pooler parameter overrides
:param paramDir: Path of parameter file
:param outputDir: Output will be written to this path
:param plotVerbosity: Plotting verbosity
:param consoleVerbosity: Console output verbosity
"""
start = time.time()
print "Running Union Pooler Capacity Experiment...\n"
print "Params dir: {0}".format(os.path.join(os.path.dirname(__file__),
paramDir))
print "Output dir: {0}\n".format(os.path.join(os.path.dirname(__file__),
outputDir))
patternDimensionality = params["patternDimensionality"]
patternCardinality = params["patternCardinality"]
sequenceLength = params["sequenceLength"]
sequenceCount = params["numberOfSequences"]
trainingPasses = params["trainingPasses"]
tmParamOverrides = params["temporalMemoryParams"]
upParamOverrides = params["unionPoolerParams"]
# Generate input data
inputSequences, seqLabels = generateSequences(patternDimensionality,
patternCardinality,
sequenceLength,
sequenceCount)
print "\nCreating Network..."
experiment = UnionPoolerExperiment(tmParamOverrides, upParamOverrides)
# Train the Temporal Memory on the generated sequences
print "\nTraining Temporal Memory..."
for i in xrange(trainingPasses):
print "\nTraining pass {0} ...\n".format(i)
experiment.runNetworkOnSequence(inputSequences,
seqLabels,
tmLearn=True,
upLearn=None,
verbosity=consoleVerbosity,
progressInterval=_SHOW_PROGRESS_INTERVAL)
if consoleVerbosity > 0:
stats = experiment.getBurstingColumnsStats()
print "\nPass\tMean\t\tStdDev\t\tMax\t\t(Bursting Columns)"
print "{0}\t{1}\t{2}\t{3}".format(i, stats[0], stats[1], stats[2])
print
print MonitorMixinBase.mmPrettyPrintMetrics(
experiment.tm.mmGetDefaultMetrics())
print
experiment.tm.mmClearHistory()
# Run test phase recording Union SDRs
unionSdrs = runTestPhase(experiment, inputSequences, seqLabels, sequenceCount,
sequenceLength, consoleVerbosity)
# Output distinctness metric
print "\nSequences\tDistinctness Ave\tStdDev\tMax"
ave, stdDev, maxDist = getDistinctness(unionSdrs)
print "{0}\t{1}\t{2}\t{3}".format(sequenceCount, ave, stdDev, maxDist)
# Check bursting columns metric during test phase
print "\nSequences\tBursting Columns Mean\tStdDev\tMax"
stats = experiment.getBurstingColumnsStats()
print "{0}\t{1}\t{2}\t{3}".format(sequenceCount, stats[0], stats[1], stats[2])
if trainingPasses > 0 and stats[0] > 0:
print "***Warning! Mean bursing columns > 0 in test phase***"
print
print MonitorMixinBase.mmPrettyPrintMetrics(
experiment.tm.mmGetDefaultMetrics() + experiment.up.mmGetDefaultMetrics())
print
print "Total time: {0:2} seconds.".format(int(time.time() - start))
def run(params, paramDir, outputDir, plotVerbosity=0, consoleVerbosity=0):
"""
Runs the union overlap experiment.
:param params: A dict of experiment parameters
:param paramDir: Path of parameter file
:param outputDir: Output will be written to this path
:param plotVerbosity: Plotting verbosity
:param consoleVerbosity: Console output verbosity
"""
print "Running SDR overlap experiment...\n"
print "Params dir: {0}".format(paramDir)
print "Output dir: {0}\n".format(outputDir)
# Dimensionality of sequence patterns
patternDimensionality = params["patternDimensionality"]
# Cardinality (ON / true bits) of sequence patterns
patternCardinality = params["patternCardinality"]
# TODO If this parameter is to be supported, the sequence generation code
# below must change
# Number of unique patterns from which sequences are built
# patternAlphabetSize = params["patternAlphabetSize"]
# Length of sequences shown to network
sequenceLength = params["sequenceLength"]
# Number of sequences used. Sequences may share common elements.
numberOfSequences = params["numberOfSequences"]
# Number of sequence passes for training the TM. Zero => no training.
trainingPasses = params["trainingPasses"]
tmParamOverrides = params["temporalMemoryParams"]
upParamOverrides = params["unionPoolerParams"]
# Generate a sequence list and an associated labeled list (both containing a
# set of sequences separated by None)
start = time.time()
print "\nGenerating sequences..."
patternAlphabetSize = sequenceLength * numberOfSequences
patternMachine = PatternMachine(patternDimensionality, patternCardinality,
patternAlphabetSize)
sequenceMachine = SequenceMachine(patternMachine)
numbers = sequenceMachine.generateNumbers(numberOfSequences, sequenceLength)
generatedSequences = sequenceMachine.generateFromNumbers(numbers)
sequenceLabels = [str(numbers[i + i*sequenceLength: i + (i+1)*sequenceLength])
for i in xrange(numberOfSequences)]
labeledSequences = []
for label in sequenceLabels:
for _ in xrange(sequenceLength):
labeledSequences.append(label)
labeledSequences.append(None)
# Set up the Temporal Memory and Union Pooler network
print "\nCreating network..."
experiment = UnionPoolerExperiment(tmParamOverrides, upParamOverrides)
# Train only the Temporal Memory on the generated sequences
if trainingPasses > 0:
print "\nTraining Temporal Memory..."
if consoleVerbosity > 0:
print "\nPass\tBursting Columns Mean\tStdDev\tMax"
for i in xrange(trainingPasses):
experiment.runNetworkOnSequence(generatedSequences,
labeledSequences,
tmLearn=True,
upLearn=None,
verbosity=consoleVerbosity,
progressInterval=_SHOW_PROGRESS_INTERVAL)
if consoleVerbosity > 0:
stats = experiment.getBurstingColumnsStats()
print "{0}\t{1}\t{2}\t{3}".format(i, stats[0], stats[1], stats[2])
# Reset the TM monitor mixin's records accrued during this training pass
experiment.tm.mmClearHistory()
print
print MonitorMixinBase.mmPrettyPrintMetrics(
experiment.tm.mmGetDefaultMetrics())
print
if plotVerbosity >= 2:
plotNetworkState(experiment, plotVerbosity, trainingPasses,
phase="Training")
print "\nRunning test phase..."
experiment.runNetworkOnSequence(generatedSequences,
labeledSequences,
tmLearn=False,
upLearn=False,
verbosity=consoleVerbosity,
progressInterval=_SHOW_PROGRESS_INTERVAL)
print "\nPass\tBursting Columns Mean\tStdDev\tMax"
stats = experiment.getBurstingColumnsStats()
print "{0}\t{1}\t{2}\t{3}".format(0, stats[0], stats[1], stats[2])
if trainingPasses > 0 and stats[0] > 0:
print "***WARNING! MEAN BURSTING COLUMNS IN TEST PHASE IS GREATER THAN 0***"
print
print MonitorMixinBase.mmPrettyPrintMetrics(
experiment.tm.mmGetDefaultMetrics() + experiment.up.mmGetDefaultMetrics())
print
plotNetworkState(experiment, plotVerbosity, trainingPasses, phase="Testing")
elapsed = int(time.time() - start)
print "Total time: {0:2} seconds.".format(elapsed)
# Write Union SDR trace
metricName = "activeCells"
outputFileName = "unionSdrTrace_{0}learningPasses.csv".format(trainingPasses)
writeMetricTrace(experiment, metricName, outputDir, outputFileName)
if plotVerbosity >= 1:
raw_input("Press any key to exit...")
def run(params, paramDir, outputDir, plotVerbosity=0, consoleVerbosity=0):
"""
Runs the noise robustness experiment.
:param params: A dict containing the following experiment parameters:
patternDimensionality - Dimensionality of sequence patterns
patternCardinality - Cardinality (# ON bits) of sequence patterns
sequenceLength - Length of sequences shown to network
sequenceCount - Number of unique sequences used
trainingPasses - Number of times Temporal Memory is trained on each
sequence
testPresentations - Number of sequences presented in test phase
perturbationChance - Chance of sequence perturbations during test phase
temporalMemoryParams - A dict of Temporal Memory parameter overrides
unionPoolerParams - A dict of Union Pooler parameter overrides
:param paramDir: Path of parameter file
:param outputDir: Output will be written to this path
:param plotVerbosity: Plotting verbosity
:param consoleVerbosity: Console output verbosity
"""
print "Running Noise robustness experiment...\n"
print "Params dir: {0}".format(os.path.join(os.path.dirname(__file__),
paramDir))
print "Output dir: {0}\n".format(os.path.join(os.path.dirname(__file__),
outputDir))
patternDimensionality = params["patternDimensionality"]
patternCardinality = params["patternCardinality"]
sequenceLength = params["sequenceLength"]
sequenceCount = params["numberOfSequences"]
trainingPasses = params["trainingPasses"]
testPresentations = params["testPresentations"]
perturbationChance = params["perturbationChance"]
tmParamOverrides = params["temporalMemoryParams"]
upParamOverrides = params["unionPoolerParams"]
# TODO If this parameter is to be supported, the sequence generation
# code below must change
# Number of unique patterns from which sequences are built
# patternAlphabetSize = params["patternAlphabetSize"]
# Generate a sequence list and an associated labeled list (both containing a
# set of sequences separated by None)
start = time.time()
print "Generating sequences..."
patternAlphabetSize = sequenceLength * sequenceCount
patternMachine = PatternMachine(patternDimensionality, patternCardinality,
patternAlphabetSize)
sequenceMachine = SequenceMachine(patternMachine)
numbers = sequenceMachine.generateNumbers(sequenceCount, sequenceLength)
generatedSequences = sequenceMachine.generateFromNumbers(numbers)
sequenceLabels = [str(numbers[i + i*sequenceLength: i + (i+1)*sequenceLength])
for i in xrange(sequenceCount)]
labeledSequences = []
for label in sequenceLabels:
for _ in xrange(sequenceLength):
labeledSequences.append(label)
labeledSequences.append(None)
# Set up the Temporal Memory and Union Pooler network
print "\nCreating network..."
experiment = UnionPoolerExperiment(tmParamOverrides, upParamOverrides)
# Train only the Temporal Memory on the generated sequences
if trainingPasses > 0:
print "\nTraining Temporal Memory..."
if consoleVerbosity > 0:
print "\nPass\tMean\t\tStdDev\t\tMax\t\t(Bursting Columns)"
for i in xrange(trainingPasses):
experiment.runNetworkOnSequence(generatedSequences,
labeledSequences,
tmLearn=True,
upLearn=None,
verbosity=consoleVerbosity,
progressInterval=_SHOW_PROGRESS_INTERVAL)
if consoleVerbosity > 0:
stats = experiment.getBurstingColumnsStats()
print "{0}\t{1}\t{2}\t{3}".format(i, stats[0], stats[1], stats[2])
# Reset the TM monitor mixin's records accrued during this training pass
# experiment.tm.mmClearHistory()
print
print MonitorMixinBase.mmPrettyPrintMetrics(
experiment.tm.mmGetDefaultMetrics())
print
if plotVerbosity >= 2:
plotNetworkState(experiment, plotVerbosity, trainingPasses,
phase="Training")
print "\nRunning test phase..."
# Input sequence pattern by pattern. Sequence-to-sequence
# progression is randomly selected. At each step there is a chance of
# perturbation. Specifically the following
# perturbations may occur:
# Establish a baseline without noise
# Establish a baseline adding the following perturbations one-by-one
# 1) substitution of some other pattern for the normal expected pattern
# 2) skipping expected pattern and presenting next pattern in sequence
# 3) addition of some other pattern putting off expected pattern one time step
# Finally measure performance on more complex perturbation
# TODO 4) Jump to another sequence randomly (Random jump to start or random
# position?)
runTestPhase(experiment, generatedSequences, sequenceCount, sequenceLength,
testPresentations, perturbationChance)
print
print MonitorMixinBase.mmPrettyPrintMetrics(
experiment.tm.mmGetDefaultMetrics() + experiment.up.mmGetDefaultMetrics())
print
# plotNetworkState(experiment, plotVerbosity, trainingPasses, phase="Testing")
elapsed = int(time.time() - start)
print "Total time: {0:2} seconds.".format(elapsed)
## Write Union SDR trace
# metricName = "activeCells"
# outputFileName = "unionSdrTrace_{0}learningPasses.csv".format(trainingPasses)
# writeMetricTrace(experiment, metricName, outputDir, outputFileName)
if plotVerbosity >= 1:
raw_input("\nPress any key to exit...")