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...")