def _createEncoder(encoders): """ Creates and returns a MultiEncoder. @param encoders: (dict) Keys are the encoders' names, values are dicts of the params; an example is shown below. @return encoder: (MultiEncoder) See nupic.encoders.multi.py. Example input: {"energy": {"fieldname": u"energy", "type": "ScalarEncoder", "name": u"consumption", "minval": 0.0, "maxval": 100.0, "w": 21, "n": 500}, "timestamp": {"fieldname": u"timestamp", "type": "DateEncoder", "name": u"timestamp_timeOfDay", "timeOfDay": (21, 9.5)}, } """ if not isinstance(encoders, dict): raise TypeError("Encoders specified in incorrect format.") encoder = MultiEncoder() encoder.addMultipleEncoders(encoders) return encoder
def _createEncoder(): """Create the encoder instance for our test and return it.""" encoder = MultiEncoder() encoder.addMultipleEncoders({ 'timestamp': dict(fieldname='timestamp', type='DateEncoder', timeOfDay=(5, 5)), 'attendeeCount': dict(fieldname='attendeeCount', type='ScalarEncoder', name='attendeeCount', minval=0, maxval=270, clipInput=True, w=5, resolution=10), 'consumption': dict(fieldname='consumption', type='ScalarEncoder', name='consumption', minval=0, maxval=115, clipInput=True, w=5, resolution=5), }) return encoder
def createEncoder(): """ Creates and returns a #MultiEncoder including a ScalarEncoder for energy consumption and a DateEncoder for the time of the day. @see nupic/encoders/__init__.py for type to file-name mapping @see nupic/encoders for encoder source files """ encoder = MultiEncoder() encoder.addMultipleEncoders({ "consumption": { "fieldname": u"consumption", "type": "ScalarEncoder", "name": u"consumption", "minval": 0.0, "maxval": 100.0, "clipInput": True, "w": 21, "n": 500 }, "timestamp_timeOfDay": { "fieldname": u"timestamp", "type": "DateEncoder", "name": u"timestamp_timeOfDay", "timeOfDay": (21, 9.5) } }) return encoder
def initialize(self): """ Initialize this node. """ Node.initialize(self) # Initialize input bits self.bits = [] for x in range(self.width): for y in range(self.height): bit = Bit() bit.x = x bit.y = y self.bits.append(bit) if self.data_source_type == DataSourceType.FILE: """ Initialize this node opening the file and place cursor on the first record. """ # If file name provided is a relative path, use project file path if self.file_name != '' and os.path.dirname(self.file_name) == '': full_file_name = os.path.dirname(Global.project.file_name) + '/' + self.file_name else: full_file_name = self.file_name # Check if file really exists if not os.path.isfile(full_file_name): QtWidgets.QMessageBox.warning(None, "Warning", "Input stream file '" + full_file_name + "' was not found or specified.", QtWidgets.QMessageBox.Ok) return # Create a data source for read the file self.data_source = FileRecordStream(full_file_name) elif self.data_source_type == DataSourceType.DATABASE: pass self.encoder = MultiEncoder() for encoding in self.encodings: encoding.initialize() # Create an instance class for an encoder given its module, class and constructor params encoding.encoder = getInstantiatedClass(encoding.encoder_module, encoding.encoder_class, encoding.encoder_params) # Take the first part of encoder field name as encoder name # Ex: timestamp_weekend.weekend => timestamp_weekend encoding.encoder.name = encoding.encoder_field_name.split('.')[0] # Add sub-encoder to multi-encoder list self.encoder.addEncoder(encoding.data_source_field_name, encoding.encoder) # If encoder size is not the same to sensor size then throws exception encoder_size = self.encoder.getWidth() sensor_size = self.width * self.height if encoder_size > sensor_size: QtWidgets.QMessageBox.warning(None, "Warning", "'" + self.name + "': Encoder size (" + str(encoder_size) + ") is different from sensor size (" + str(self.width) + " x " + str(self.height) + " = " + str(sensor_size) + ").", QtWidgets.QMessageBox.Ok) return return True
def createEncoder(encoderParams): ''' Create a multi-encoder from params. ''' encoder = MultiEncoder() encoder.addMultipleEncoders(encoderParams) return encoder
def createEncoder(rdse_resolution): """Create the encoder instance for our test and return it.""" series_rdse = RandomDistributedScalarEncoder( rdse_resolution, name="rdse with resolution {}".format(rdse_resolution)) encoder = MultiEncoder() encoder.addEncoder("series", series_rdse) return encoder
def __init__(self, resolution=.5): """Create the encoder instance for our test and return it.""" self.resolution = resolution self.series_encoder = RandomDistributedScalarEncoder( self.resolution, name="RDSE-(res={})".format(self.resolution)) self.encoder = MultiEncoder() self.encoder.addEncoder("series", self.series_encoder) self.last_m_encode = np.zeros(1)
def createEncoder(): """Create the encoder instance for our test and return it.""" consumption_encoder = ScalarEncoder(21, 0.0, 100.0, n=50, name="consumption", clipInput=True) time_encoder = DateEncoder(timeOfDay=(21, 9.5), name="timestamp_timeOfDay") encoder = MultiEncoder() encoder.addEncoder("consumption", consumption_encoder) encoder.addEncoder("timestamp", time_encoder) return encoder
def createClassifierEncoder(): """Create the encoder instance for our test and return it.""" encoder = MultiEncoder() encoder.addMultipleEncoders({ "y": { "type": "CategoryEncoder", "categoryList": ['label_1', 'label_2'], "fieldname": u"y", "name": u"y", "w": 21, }, }) return encoder
def createEncoder(): diagCoorA_encoder = ScalarEncoder(55, 0.0, 200.0, n=200, name="diagCoorA") diagCoorB_encoder = ScalarEncoder(55, 0.0, 200.0, n=200, name="diagCoorB") diagCoorC_encoder = ScalarEncoder(55, 0.0, 200.0, n=200, name="diagCoorC") global encoder encoder = MultiEncoder() encoder.addEncoder("diagCoorA", diagCoorA_encoder) encoder.addEncoder("diagCoorB", diagCoorB_encoder) encoder.addEncoder("diagCoorC", diagCoorC_encoder) return encoder
def createSensorEncoder(): """Create the encoder instance for our test and return it.""" encoder = MultiEncoder() encoder.addMultipleEncoders({ "x": { "type": "ScalarEncoder", "fieldname": u"x", "name": u"x", "maxval": 100.0, "minval": 0.0, "n": 100, "w": 21, "clipInput": True, }, }) return encoder
def _makeRegion(self, name, params): sp_name = "sp_" + name if self.tp_enable: tp_name = "tp_" + name class_name = "class_" + name # addRegion self.network.addRegion(sp_name, "py.SPRegion", json.dumps(params['SP_PARAMS'])) if self.tp_enable: self.network.addRegion(tp_name, "py.TPRegion", json.dumps(params['TP_PARAMS'])) self.network.addRegion( class_name, "py.CLAClassifierRegion", json.dumps(params['CLASSIFIER_PARAMS'])) encoder = MultiEncoder() encoder.addMultipleEncoders(self.class_encoder_params) self.classifier_encoder_list[class_name] = encoder if self.tp_enable: self.classifier_input_list[class_name] = tp_name else: self.classifier_input_list[class_name] = sp_name
def createEncoder(multilevelAnomaly=False): encoder = MultiEncoder() if multilevelAnomaly == False: encoder.addMultipleEncoders({ "cpu": { "fieldname": u"cpu", "type": "ScalarEncoder", "name": u"cpu", "minval": 0.0, "maxval": 100.0, "clipInput": True, "w": 21, "n": 500 } }) else: encoder.addMultipleEncoders({ "cpu": { "fieldname": u"cpu", "type": "ScalarEncoder", "name": u"cpu", "minval": 0.0, "maxval": 100.0, "clipInput": True, "w": 21, "n": 500 }, "mem": { "fieldname": u"mem", "type": "ScalarEncoder", "name": u"mem", "minval": 0.0, "maxval": 100.0, "clipInput": True, "w": 21, "n": 500 } }) return encoder
def createEncoder(): #volume_encoder = ScalarEncoder(7, 0.0, 70.0, n=200, name="volume", clipInput=False, forced=True) #floorheight_encoder = ScalarEncoder(1, 0.0, 70.0, n=25, name="floorheight", clipInput=False, forced=True) diagCoorA_encoder = ScalarEncoder(257, 0.0, 200.0, n=2048, name="diagCoorA", clipInput=False, forced=True) #diagCoorB_encoder = ScalarEncoder(157, 0.0, 200.0, n=2000, name="diagCoorB", clipInput=False, forced=True) #diagCoorC_encoder = ScalarEncoder(157, 0.0, 200.0, n=2000, name="diagCoorC", clipInput=False, forced=True) #diagCoorD_encoder = ScalarEncoder(157, 0.0, 200.0, n=2000, name="diagCoorD", clipInput=False, forced=True) #diagCoorE_encoder = ScalarEncoder(157, 0.0, 200.0, n=2000, name="diagCoorE", clipInput=False, forced=True) #diagCoorF_encoder = ScalarEncoder(157, 0.0, 200.0, n=2000, name="diagCoorF", clipInput=False, forced=True) #diagCoorG_encoder = ScalarEncoder(157, 0.0, 200.0, n=2000, name="diagCoorG", clipInput=False, forced=True) #diagCoorH_encoder = ScalarEncoder(157, 0.0, 200.0, n=2000, name="diagCoorH", clipInput=False, forced=True) #diagCoorI_encoder = ScalarEncoder(157, 0.0, 200.0, n=2000, name="diagCoorI", clipInput=False, forced=True) #diagCoorJ_encoder = ScalarEncoder(157, 0.0, 200.0, n=2000, name="diagCoorJ", clipInput=False, forced=True) global encoder encoder = MultiEncoder() #encoder.addEncoder("volume", volume_encoder) #encoder.addEncoder("floorheight", floorheight_encoder) encoder.addEncoder("diagCoorA", diagCoorA_encoder) #encoder.addEncoder("diagCoorB", diagCoorB_encoder) #encoder.addEncoder("diagCoorC", diagCoorC_encoder) #encoder.addEncoder("diagCoorD", diagCoorD_encoder) #encoder.addEncoder("diagCoorE", diagCoorE_encoder) #encoder.addEncoder("diagCoorF", diagCoorF_encoder) #encoder.addEncoder("diagCoorG", diagCoorG_encoder) #encoder.addEncoder("diagCoorH", diagCoorH_encoder) #encoder.addEncoder("diagCoorI", diagCoorI_encoder) #encoder.addEncoder("diagCoorJ", diagCoorJ_encoder) return encoder
def createEncoder(): """Create the encoder instance for our test and return it.""" encoder = MultiEncoder() encoder.addMultipleEncoders({ "consumption": { "clipInput": True, "fieldname": u"consumption", "maxval": 100.0, "minval": 0.0, "n": 50, "name": u"consumption", "type": "ScalarEncoder", "w": 21, }, "timestamp_timeOfDay": { "fieldname": u"timestamp", "name": u"timestamp_timeOfDay", "timeOfDay": (21, 9.5), "type": "DateEncoder", }, }) return encoder
def createEncoder(): diagCoorA_encoder = ScalarEncoder(105, 0.0, 200.0, n=1324, name="diagCoorA", clipInput=False, forced=True) diagCoorB_encoder = ScalarEncoder(105, 0.0, 200.0, n=1324, name="diagCoorB", clipInput=False, forced=True) global encoder encoder = MultiEncoder() encoder.addEncoder("diagCoorA", diagCoorA_encoder) encoder.addEncoder("diagCoorB", diagCoorB_encoder) return encoder
def testDeltaFilter(self): """ data looks like: should generate deltas "t" "s" "dt" "ds" t 10 X t+1s 20 1s 10 t+1d 50 86399 30 r t+1d+1s 60 X r+1d+3s 65 2s 5 """ r = RecordSensor() filename = findDataset("extra/qa/delta.csv") datasource = FileRecordStream(filename) r.dataSource = datasource n = 50 encoder = MultiEncoder({ 'blah': dict(fieldname="s", type='ScalarEncoder', n=n, w=11, minval=0, maxval=100) }) r.encoder = encoder # Test #1 -- no deltas # Make sure we get a reset when the gym changes resetOut = numpy.zeros((1, ), dtype='float') sequenceIdOut = numpy.zeros((1, ), dtype='float') dataOut = numpy.zeros((n, ), dtype='float') sourceOut = numpy.zeros((1, ), dtype='float') categoryOut = numpy.zeros((1, ), dtype='float') outputs = dict(resetOut=resetOut, sourceOut=sourceOut, sequenceIdOut=sequenceIdOut, dataOut=dataOut, categoryOut=categoryOut) inputs = dict() r.verbosity = 0 r.compute(inputs, outputs) lr = r.lastRecord self.assertEqual( lr['t'], datetime(year=2011, month=2, day=24, hour=16, minute=8, second=0)) self.assertEqual(lr['s'], 10) self.assertEqual(lr['_reset'], 1) self.assertTrue('dt' not in lr) self.assertTrue('ds' not in lr) r.compute(inputs, outputs) lr = r.lastRecord self.assertEqual( lr['t'], datetime(year=2011, month=2, day=24, hour=16, minute=8, second=1)) self.assertEqual(lr['s'], 20) self.assertEqual(lr['_reset'], 0) r.compute(inputs, outputs) lr = r.lastRecord self.assertEqual( lr['t'], datetime(year=2011, month=2, day=25, hour=16, minute=8, second=0)) self.assertEqual(lr['s'], 50) self.assertEqual(lr['_reset'], 0) r.compute(inputs, outputs) lr = r.lastRecord self.assertEqual( lr['t'], datetime(year=2011, month=2, day=25, hour=16, minute=8, second=1)) self.assertEqual(lr['s'], 60) self.assertEqual(lr['_reset'], 1) r.compute(inputs, outputs) lr = r.lastRecord self.assertEqual( lr['t'], datetime(year=2011, month=2, day=25, hour=16, minute=8, second=3)) self.assertEqual(lr['s'], 65) self.assertEqual(lr['_reset'], 0) # Add filters r.preEncodingFilters = [DeltaFilter("s", "ds"), DeltaFilter("t", "dt")] r.rewind() # skip first record, which has a reset r.compute(inputs, outputs) lr = r.lastRecord self.assertEqual( lr['t'], datetime(year=2011, month=2, day=24, hour=16, minute=8, second=1)) self.assertEqual(lr['s'], 20) self.assertEqual(lr['_reset'], 1) # this record should have a reset since # it is first of a sequence self.assertEqual(lr['dt'], 1) self.assertEqual(lr['ds'], 10) r.compute(inputs, outputs) lr = r.lastRecord self.assertEqual( lr['t'], datetime(year=2011, month=2, day=25, hour=16, minute=8, second=0)) self.assertEqual(lr['s'], 50) self.assertEqual(lr['_reset'], 0) self.assertEqual(lr['dt'], 3600 * 24 - 1) self.assertEqual(lr['ds'], 30) # next reset record is skipped r.compute(inputs, outputs) lr = r.lastRecord self.assertEqual( lr['t'], datetime(year=2011, month=2, day=25, hour=16, minute=8, second=3)) self.assertEqual(lr['s'], 65) self.assertEqual(lr['_reset'], 1) self.assertEqual(lr['dt'], 2) self.assertEqual(lr['ds'], 5)
def testSimpleMulticlassNetworkPY(self): # Setup data record stream of fake data (with three categories) filename = _getTempFileName() fields = [("timestamp", "datetime", "T"), ("value", "float", ""), ("reset", "int", "R"), ("sid", "int", "S"), ("categories", "list", "C")] records = ([datetime(day=1, month=3, year=2010), 0.0, 1, 0, "0"], [ datetime(day=2, month=3, year=2010), 1.0, 0, 0, "1" ], [datetime(day=3, month=3, year=2010), 0.0, 0, 0, "0"], [datetime(day=4, month=3, year=2010), 1.0, 0, 0, "1"], [datetime(day=5, month=3, year=2010), 0.0, 0, 0, "0"], [datetime(day=6, month=3, year=2010), 1.0, 0, 0, "1" ], [datetime(day=7, month=3, year=2010), 0.0, 0, 0, "0"], [datetime(day=8, month=3, year=2010), 1.0, 0, 0, "1"]) dataSource = FileRecordStream(streamID=filename, write=True, fields=fields) for r in records: dataSource.appendRecord(list(r)) # Create the network and get region instances. net = Network() net.addRegion("sensor", "py.RecordSensor", "{'numCategories': 3}") net.addRegion("classifier", "py.SDRClassifierRegion", "{steps: '0', alpha: 0.001, implementation: 'py'}") net.link("sensor", "classifier", "UniformLink", "", srcOutput="dataOut", destInput="bottomUpIn") net.link("sensor", "classifier", "UniformLink", "", srcOutput="categoryOut", destInput="categoryIn") sensor = net.regions["sensor"] classifier = net.regions["classifier"] # Setup sensor region encoder and data stream. dataSource.close() dataSource = FileRecordStream(filename) sensorRegion = sensor.getSelf() sensorRegion.encoder = MultiEncoder() sensorRegion.encoder.addEncoder( "value", ScalarEncoder(21, 0.0, 13.0, n=256, name="value")) sensorRegion.dataSource = dataSource # Get ready to run. net.initialize() # Train the network (by default learning is ON in the classifier, but assert # anyway) and then turn off learning and turn on inference mode. self.assertEqual(classifier.getParameter("learningMode"), 1) net.run(8) # Test the network on the same data as it trained on; should classify with # 100% accuracy. classifier.setParameter("inferenceMode", 1) classifier.setParameter("learningMode", 0) # Assert learning is OFF and that the classifier learned the dataset. self.assertEqual(classifier.getParameter("learningMode"), 0, "Learning mode is not turned off.") self.assertEqual(classifier.getParameter("inferenceMode"), 1, "Inference mode is not turned on.") # make sure we can access all the parameters with getParameter self.assertEqual(classifier.getParameter("maxCategoryCount"), 2000) self.assertAlmostEqual(float(classifier.getParameter("alpha")), 0.001) self.assertEqual(int(classifier.getParameter("steps")), 0) self.assertTrue(classifier.getParameter("implementation") == "py") self.assertEqual(classifier.getParameter("verbosity"), 0) expectedCats = ( [0.0], [1.0], [0.0], [1.0], [0.0], [1.0], [0.0], [1.0], ) dataSource.rewind() for i in xrange(8): net.run(1) inferredCats = classifier.getOutputData("categoriesOut") self.assertSequenceEqual( expectedCats[i], inferredCats.tolist(), "Classififer did not infer expected category " "for record number {}.".format(i)) # Close data stream, delete file. dataSource.close() os.remove(filename)
def _createNetwork(self): def deepupdate(original, update): """ Recursively update a dict. Subdict's won't be overwritten but also updated. """ if update is None: return None for key, value in original.iteritems(): if not key in update: update[key] = value elif isinstance(value, dict): deepupdate(value, update[key]) return update self.network = Network() # check if self.selectivity not in self.dest_resgion_data.keys(): raise Exception, "There is no selected region : " + self.selectivity if not len(self.net_structure.keys()) == len(set(self.net_structure.keys())): raise Exception, "There is deplicated net_structure keys : " + self.net_structure.keys() # sensor for sensor_name, change_params in self.sensor_params.items(): self.network.addRegion(sensor_name, "py.RecordSensor", json.dumps({"verbosity": 0})) sensor = self.network.regions[sensor_name].getSelf() # set encoder params = deepupdate(cn.SENSOR_PARAMS, change_params) encoder = MultiEncoder() encoder.addMultipleEncoders( params ) sensor.encoder = encoder # set datasource sensor.dataSource = cn.DataBuffer() # network print 'create network ...' for source, dest_list in self.net_structure.items(): for dest in dest_list: change_params = self.dest_resgion_data[dest] params = deepupdate(cn.PARAMS, change_params) if source in self.sensor_params.keys(): sensor = self.network.regions[source].getSelf() params['SP_PARAMS']['inputWidth'] = sensor.encoder.getWidth() self._addRegion(source, dest, params) else: #self._addRegion("sp_" + source, dest, params) self._addRegion("tp_" + source, dest, params) # initialize print 'initializing network ...' self.network.initialize() for name in set( itertools.chain.from_iterable( self.net_structure.values() )): self._initRegion(name) # TODO: 1-3-1構造で, TPのセル数をむやみに増やすことは逆効果になるのでは? return
def getDescription(datasets): # ======================================================================== # Network definition # Encoder for the sensor encoder = MultiEncoder() if 'filenameCategory' in datasets: categories = [x.strip() for x in open(datasets['filenameCategory'])] else: categories = [chr(x + ord('a')) for x in range(26)] if config['overlappingPatterns']: encoder.addEncoder( "name", SDRCategoryEncoder(n=200, w=config['spNumActivePerInhArea'], categoryList=categories, name="name")) else: encoder.addEncoder( "name", CategoryEncoder(w=config['spNumActivePerInhArea'], categoryList=categories, name="name")) # ------------------------------------------------------------------ # Node params # The inputs are long, horizontal vectors inputDimensions = (1, encoder.getWidth()) # Layout the coincidences vertically stacked on top of each other, each # looking at the entire input field. columnDimensions = (config['spCoincCount'], 1) # If we have disableSpatial, then set the number of "coincidences" to be the # same as the encoder width if config['disableSpatial']: columnDimensions = (encoder.getWidth(), 1) config['trainSP'] = 0 sensorParams = dict( # encoder/datasource are not parameters so don't include here verbosity=config['sensorVerbosity']) CLAParams = dict( # SP params disableSpatial=config['disableSpatial'], inputDimensions=inputDimensions, columnDimensions=columnDimensions, potentialRadius=inputDimensions[1] / 2, potentialPct=1.00, gaussianDist=0, commonDistributions=0, # should be False if possibly not training localAreaDensity=-1, #0.05, numActiveColumnsPerInhArea=config['spNumActivePerInhArea'], dutyCyclePeriod=1000, stimulusThreshold=1, synPermInactiveDec=0.11, synPermActiveInc=0.11, synPermActiveSharedDec=0.0, synPermOrphanDec=0.0, minPctDutyCycleBeforeInh=0.001, minPctDutyCycleAfterInh=0.001, spVerbosity=config['spVerbosity'], spSeed=1, printPeriodicStats=int(config['spPrintPeriodicStats']), # TM params tpSeed=1, disableTemporal=0 if config['trainTP'] else 1, temporalImp=config['temporalImp'], nCellsPerCol=config['tpNCellsPerCol'] if config['trainTP'] else 1, collectStats=1, burnIn=2, verbosity=config['tpVerbosity'], newSynapseCount=config['spNumActivePerInhArea'], minThreshold=config['spNumActivePerInhArea'], activationThreshold=config['spNumActivePerInhArea'], initialPerm=config['tpInitialPerm'], connectedPerm=0.5, permanenceInc=config['tpPermanenceInc'], permanenceDec=config['tpPermanenceDec'], # perhaps tune this globalDecay=config['tpGlobalDecay'], pamLength=config['tpPAMLength'], maxSeqLength=config['tpMaxSeqLength'], maxAge=config['tpMaxAge'], # General params computeTopDown=config['computeTopDown'], trainingStep='spatial', ) dataSource = FileRecordStream(datasets['filenameTrain']) description = dict( options=dict(logOutputsDuringInference=False, ), network=dict(sensorDataSource=dataSource, sensorEncoder=encoder, sensorParams=sensorParams, CLAType='py.CLARegion', CLAParams=CLAParams, classifierType=None, classifierParams=None), ) if config['trainSP']: description['spTrain'] = dict( iterationCount=config['iterationCountTrain'], #iter=displaySPCoincidences(50), #finish=printSPCoincidences() ), else: description['spTrain'] = dict( # need to train with one iteration just to initialize data structures iterationCount=1) if config['trainTP']: description['tpTrain'] = [] for i in range(config['trainTPRepeats']): stepDict = dict( name='step_%d' % (i), setup=sensorRewind, iterationCount=config['iterationCountTrain'], ) if config['tpTimingEvery'] > 0: stepDict['iter'] = printTPTiming(config['tpTimingEvery']) stepDict['finish'] = [printTPTiming(), printTPCells] description['tpTrain'].append(stepDict) # ---------------------------------------------------------------------------- # Inference tests inferSteps = [] if config['evalTrainingSetNumIterations'] > 0: # The training set. Used to train the n-grams. inferSteps.append( dict( name='confidenceTrain_baseline', iterationCount=min(config['evalTrainingSetNumIterations'], config['iterationCountTrain']), ppOptions=dict( verbosity=config['ppVerbosity'], printLearnedCoincidences=True, nGrams='train', #ipsDetailsFor = "name,None,2", ), #finish=printTPCells, )) # Testing the training set on both the TM and n-grams. inferSteps.append( dict( name='confidenceTrain_nonoise', iterationCount=min(config['evalTrainingSetNumIterations'], config['iterationCountTrain']), setup=[sensorOpen(datasets['filenameTrain'])], ppOptions=dict( verbosity=config['ppVerbosity'], printLearnedCoincidences=False, nGrams='test', burnIns=[1, 2, 3, 4], #ipsDetailsFor = "name,None,2", #ipsAt = [1,2,3,4], ), )) # The test set if True: if datasets['filenameTest'] != datasets['filenameTrain']: inferSteps.append( dict( name='confidenceTest_baseline', iterationCount=config['iterationCountTest'], setup=[sensorOpen(datasets['filenameTest'])], ppOptions=dict( verbosity=config['ppVerbosity'], printLearnedCoincidences=False, nGrams='test', burnIns=[1, 2, 3, 4], #ipsAt = [1,2,3,4], ipsDetailsFor="name,None,2", ), )) description['infer'] = inferSteps return description
def __init__(self, columnCount, InputEncoderParams, toL4ConnectorParamsI, toL4ConnectorParamsII, toL5ConnectorParams, toD1ConnectorParams, toD2ConnectorParams, L4Params, L5Params, k, D1Params, D2Params): self.columnCount = columnCount self.toL4ConnectorParamsI = toL4ConnectorParamsI self.toL4ConnectorParamsII = toL4ConnectorParamsII self.toL5ConnectorParams = toL5ConnectorParams self.toD1ConnectorParams = toD1ConnectorParams self.toD2ConnectorParams = toD2ConnectorParams self.L4Params = L4Params self.L5Params = L5Params self.k = k self.D1Params = D1Params self.D2Params = D2Params self.learning = False #encoder from nupic.encoders import MultiEncoder self.InputEncoder = MultiEncoder() self.InputEncoder.addMultipleEncoders(InputEncoderParams) print "Encoder Online" #spatialPoolers from nupic.algorithms.spatial_pooler import SpatialPooler self.toL4ConnectorI = SpatialPooler( inputDimensions=(toL4ConnectorParamsI["inputDimensions"], ), columnDimensions=(columnCount, ), potentialPct=toL4ConnectorParamsI["potentialPct"], globalInhibition=toL4ConnectorParamsI["globalInhibition"], localAreaDensity=toL4ConnectorParamsI["localAreaDensity"], numActiveColumnsPerInhArea=toL4ConnectorParamsI[ "numActiveColumnsPerInhArea"], synPermInactiveDec=toL4ConnectorParamsI["synPermInactiveDec"], synPermActiveInc=toL4ConnectorParamsI["synPermActiveInc"], synPermConnected=toL4ConnectorParamsI["synPermConnected"], boostStrength=toL4ConnectorParamsI["boostStrength"], seed=toL4ConnectorParamsI["seed"], wrapAround=toL4ConnectorParamsI["wrapAround"]) #this part sucks self.toL4ConnectorII = SpatialPooler( inputDimensions=(columnCount * 3, ), columnDimensions=(columnCount, ), potentialPct=toL4ConnectorParamsII["potentialPct"], globalInhibition=toL4ConnectorParamsII["globalInhibition"], localAreaDensity=toL4ConnectorParamsII["localAreaDensity"], numActiveColumnsPerInhArea=toL4ConnectorParamsII[ "numActiveColumnsPerInhArea"], synPermInactiveDec=toL4ConnectorParamsII["synPermInactiveDec"], synPermActiveInc=toL4ConnectorParamsII["synPermActiveInc"], synPermConnected=toL4ConnectorParamsII["synPermConnected"], boostStrength=toL4ConnectorParamsII["boostStrength"], seed=toL4ConnectorParamsII["seed"], wrapAround=toL4ConnectorParamsII["wrapAround"]) print "toL4Connector Online" self.toL5Connector = SpatialPooler( inputDimensions=(columnCount, ), columnDimensions=(columnCount, ), potentialPct=toL5ConnectorParams["potentialPct"], globalInhibition=toL5ConnectorParams["globalInhibition"], localAreaDensity=toL5ConnectorParams["localAreaDensity"], numActiveColumnsPerInhArea=toL5ConnectorParams[ "numActiveColumnsPerInhArea"], synPermInactiveDec=toL5ConnectorParams["synPermInactiveDec"], synPermActiveInc=toL5ConnectorParams["synPermActiveInc"], synPermConnected=toL5ConnectorParams["synPermConnected"], boostStrength=toL5ConnectorParams["boostStrength"], seed=toL5ConnectorParams["seed"], wrapAround=toL5ConnectorParams["wrapAround"]) print "toL5Connector Online" self.toD1Connector = SpatialPooler( inputDimensions=(columnCount, ), columnDimensions=(columnCount, ), potentialPct=toD1ConnectorParams["potentialPct"], globalInhibition=toD1ConnectorParams["globalInhibition"], localAreaDensity=toD1ConnectorParams["localAreaDensity"], numActiveColumnsPerInhArea=toD1ConnectorParams[ "numActiveColumnsPerInhArea"], synPermInactiveDec=toD1ConnectorParams["synPermInactiveDec"], synPermActiveInc=toD1ConnectorParams["synPermActiveInc"], synPermConnected=toD1ConnectorParams["synPermConnected"], boostStrength=toD1ConnectorParams["boostStrength"], seed=toD1ConnectorParams["seed"], wrapAround=toD1ConnectorParams["wrapAround"]) print "toD1Connector Online" self.toD2Connector = SpatialPooler( inputDimensions=(columnCount, ), columnDimensions=(columnCount, ), potentialPct=toD2ConnectorParams["potentialPct"], globalInhibition=toD2ConnectorParams["globalInhibition"], localAreaDensity=toD2ConnectorParams["localAreaDensity"], numActiveColumnsPerInhArea=toD2ConnectorParams[ "numActiveColumnsPerInhArea"], synPermInactiveDec=toD2ConnectorParams["synPermInactiveDec"], synPermActiveInc=toD2ConnectorParams["synPermActiveInc"], synPermConnected=toD2ConnectorParams["synPermConnected"], boostStrength=toD2ConnectorParams["boostStrength"], seed=toD2ConnectorParams["seed"], wrapAround=toD2ConnectorParams["wrapAround"]) print "toD2Connector Online" #HTM Layers from nupic.algorithms.temporal_memory import TemporalMemory self.L4ActiveColumns = numpy.zeros(self.columnCount, dtype=int) self.L4 = TemporalMemory( columnDimensions=(columnCount, ), seed=42, ) print "L4 Online" self.L5ActiveColumns = numpy.zeros(self.columnCount, dtype=int) self.L5 = TemporalMemory( columnDimensions=(columnCount, ), seed=42, ) print "L5 Online" self.D1ActiveColumns = numpy.zeros(self.columnCount, dtype=int) self.D1 = TemporalMemory( columnDimensions=(columnCount, ), seed=42, initialPermanence=0.21, connectedPermanence=0.5, ) print "D1 Online" self.D2ActiveColumns = numpy.zeros(self.columnCount, dtype=int) self.D2 = TemporalMemory( columnDimensions=(columnCount, ), seed=42, initialPermanence=0.21, connectedPermanence=0.5, ) print "D2 Online"
half_of_year_enc = ScalarEncoder(w=1, minval=0, maxval=2, radius=1, periodic=True, name="halfOfYear", forced=True) year_of_decade_enc = ScalarEncoder(w=3, minval=0, maxval=10, radius=1.5, periodic=True, name="yearOfDecade", forced=True) date_enc = MultiEncoder() date_enc.addEncoder(day_of_week_enc.name, day_of_week_enc) date_enc.addEncoder(day_of_month_enc.name, day_of_month_enc) date_enc.addEncoder(first_last_of_month_enc.name, first_last_of_month_enc) date_enc.addEncoder(week_of_month_enc.name, week_of_month_enc) date_enc.addEncoder(year_of_decade_enc.name, year_of_decade_enc) date_enc.addEncoder(month_of_year_enc.name, month_of_year_enc) date_enc.addEncoder(quarter_of_year_enc.name, quarter_of_year_enc) date_enc.addEncoder(half_of_year_enc.name, half_of_year_enc) if os.path.isfile('tp.p'): print "loading TP from tp.p and tp.tp" with open("tp.p", "r") as f: tp = pickle.load(f) tp.loadFromFile("tp.tp") else:
def getDescription(datasets): # ======================================================================== # Encoder for the sensor encoder = MultiEncoder() if config['encodingFieldStyleA'] == 'contiguous': encoder.addEncoder('fieldA', ScalarEncoder(w=config['encodingOnBitsA'], n=config['encodingFieldWidthA'], minval=0, maxval=config['numAValues'], periodic=True, name='fieldA')) elif config['encodingFieldStyleA'] == 'sdr': encoder.addEncoder('fieldA', SDRCategoryEncoder(w=config['encodingOnBitsA'], n=config['encodingFieldWidthA'], categoryList=range(config['numAValues']), name='fieldA')) else: assert False if config['encodingFieldStyleB'] == 'contiguous': encoder.addEncoder('fieldB', ScalarEncoder(w=config['encodingOnBitsB'], n=config['encodingFieldWidthB'], minval=0, maxval=config['numBValues'], periodic=True, name='fieldB')) elif config['encodingFieldStyleB'] == 'zero': encoder.addEncoder('fieldB', SDRRandomEncoder(w=0, n=config['encodingFieldWidthB'], name='fieldB')) elif config['encodingFieldStyleB'] == 'sdr': encoder.addEncoder('fieldB', SDRCategoryEncoder(w=config['encodingOnBitsB'], n=config['encodingFieldWidthB'], categoryList=range(config['numBValues']), name='fieldB')) else: assert False # ======================================================================== # Network definition # ------------------------------------------------------------------ # Node params # The inputs are long, horizontal vectors inputShape = (1, encoder.getWidth()) # Layout the coincidences vertically stacked on top of each other, each # looking at the entire input field. coincidencesShape = (config['spCoincCount'], 1) inputBorder = inputShape[1]/2 if inputBorder*2 >= inputShape[1]: inputBorder -= 1 sensorParams = dict( # encoder/datasource are not parameters so don't include here verbosity=config['sensorVerbosity'] ) CLAParams = dict( inputShape = inputShape, inputBorder = inputBorder, coincidencesShape = coincidencesShape, coincInputRadius = inputShape[1]/2, coincInputPoolPct = 1.0, gaussianDist = 0, commonDistributions = 0, # should be False if possibly not training localAreaDensity = -1, #0.05, numActivePerInhArea = config['spNumActivePerInhArea'], dutyCyclePeriod = 1000, stimulusThreshold = 1, synPermInactiveDec = config['spSynPermInactiveDec'], synPermActiveInc = 0.02, synPermActiveSharedDec=0.0, synPermOrphanDec = 0.0, minPctDutyCycleBeforeInh = 0.001, minPctDutyCycleAfterInh = config['spMinPctDutyCycleAfterInh'], minDistance = 0.05, computeTopDown = 1, spVerbosity = config['spVerbosity'], spSeed = 1, printPeriodicStats = int(config['spPeriodicStats']), # TP params disableTemporal = 1, # General params trainingStep = 'spatial', ) trainingDataSource = FileRecordStream(datasets['trainingFilename']) description = dict( options = dict( logOutputsDuringInference = False, ), network = dict( sensorDataSource = trainingDataSource, sensorEncoder = encoder, sensorParams = sensorParams, CLAType = 'py.CLARegion', CLAParams = CLAParams, classifierType = None, classifierParams = None), ) if config['trainSP']: description['spTrain'] = dict( iterationCount=config['iterationCount'], #iter=displaySPCoincidences(50), finish=printSPCoincidences() ), else: description['spTrain'] = dict( # need to train with one iteration just to initialize data structures iterationCount=1) # ============================================================================ # Inference tests inferSteps = [] # ---------------------------------------- # Training dataset if True: datasetName = 'bothTraining' inferSteps.append( dict(name = '%s_baseline' % datasetName, iterationCount = config['iterationCount'], setup = [sensorOpen(datasets['trainingFilename'])], ppOptions = dict(printLearnedCoincidences=True), ) ) inferSteps.append( dict(name = '%s_acc' % datasetName, iterationCount = config['iterationCount'], setup = [sensorOpen(datasets['trainingFilename'])], ppOptions = dict(onlyClassificationAcc=True, tpActivationThresholds=config['tpActivationThresholds'], computeDistances=True, verbosity = 1), ) ) # ---------------------------------------- # Testing dataset if 'testingFilename' in datasets: datasetName = 'bothTesting' inferSteps.append( dict(name = '%s_baseline' % datasetName, iterationCount = config['iterationCount'], setup = [sensorOpen(datasets['testingFilename'])], ppOptions = dict(printLearnedCoincidences=False), ) ) inferSteps.append( dict(name = '%s_acc' % datasetName, iterationCount = config['iterationCount'], setup = [sensorOpen(datasets['testingFilename'])], ppOptions = dict(onlyClassificationAcc=True, tpActivationThresholds=config['tpActivationThresholds']), ) ) description['infer'] = inferSteps return description
def _createNetwork(self): def deepupdate(original, update): """ Recursively update a dict. Subdict's won't be overwritten but also updated. """ if update is None: return None for key, value in original.iteritems(): if not key in update: update[key] = value elif isinstance(value, dict): deepupdate(value, update[key]) return update self.network = Network() # check # if self.selectivity not in self.dest_region_params.keys(): # raise Exception, "There is no selected region : " + self.selectivity if not len(self.net_structure.keys()) == len( set(self.net_structure.keys())): raise Exception, "There is deplicated net_structure keys : " + self.net_structure.keys( ) # sensor for sensor_name, params in self.sensor_params.items(): self.network.addRegion(sensor_name, "py.RecordSensor", json.dumps({"verbosity": 0})) sensor = self.network.regions[sensor_name].getSelf() # set encoder #params = deepupdate(cn.SENSOR_PARAMS, params) encoder = MultiEncoder() encoder.addMultipleEncoders(params) sensor.encoder = encoder sensor.dataSource = DataBuffer() # network print 'create element ...' for name in self.dest_region_params.keys(): change_params = self.dest_region_params[name] params = deepupdate(self.default_params, change_params) # input width input_width = 0 for source in [ s for s, d in self.net_structure.items() if name in d ]: if source in self.sensor_params.keys(): sensor = self.network.regions[source].getSelf() input_width += sensor.encoder.getWidth() else: input_width += params['TP_PARAMS'][ 'cellsPerColumn'] * params['TP_PARAMS']['columnCount'] params['SP_PARAMS']['inputWidth'] = input_width self._makeRegion(name, params) # link print 'link network ...' for source, dest_list in self.net_structure.items(): for dest in dest_list: if source in self.sensor_params.keys(): self._linkRegion(source, dest) else: if self.tp_enable: self._linkRegion("tp_" + source, dest) else: self._linkRegion("sp_" + source, dest) # initialize print 'initializing network ...' self.network.initialize() for name in self.dest_region_params.keys(): self._initRegion(name) return
def testSimpleMulticlassNetwork(self): # Setup data record stream of fake data (with three categories) filename = _getTempFileName() fields = [("timestamp", "datetime", "T"), ("value", "float", ""), ("reset", "int", "R"), ("sid", "int", "S"), ("categories", "list", "C")] records = ([datetime(day=1, month=3, year=2010), 0.0, 1, 0, ""], [ datetime(day=2, month=3, year=2010), 1.0, 0, 0, "1 2" ], [datetime(day=3, month=3, year=2010), 1.0, 0, 0, "1 2"], [datetime(day=4, month=3, year=2010), 2.0, 0, 0, "0"], [ datetime(day=5, month=3, year=2010), 3.0, 0, 0, "1 2" ], [datetime(day=6, month=3, year=2010), 5.0, 0, 0, "1 2"], [datetime(day=7, month=3, year=2010), 8.0, 0, 0, "0"], [datetime(day=8, month=3, year=2010), 13.0, 0, 0, "1 2"]) dataSource = FileRecordStream(streamID=filename, write=True, fields=fields) for r in records: dataSource.appendRecord(list(r)) # Create the network and get region instances. net = Network() net.addRegion("sensor", "py.RecordSensor", "{'numCategories': 3}") net.addRegion("classifier", "py.KNNClassifierRegion", "{'k': 2,'distThreshold': 0,'maxCategoryCount': 3}") net.link("sensor", "classifier", "UniformLink", "", srcOutput="dataOut", destInput="bottomUpIn") net.link("sensor", "classifier", "UniformLink", "", srcOutput="categoryOut", destInput="categoryIn") sensor = net.regions["sensor"] classifier = net.regions["classifier"] # Setup sensor region encoder and data stream. dataSource.close() dataSource = FileRecordStream(filename) sensorRegion = sensor.getSelf() sensorRegion.encoder = MultiEncoder() sensorRegion.encoder.addEncoder( "value", ScalarEncoder(21, 0.0, 13.0, n=256, name="value")) sensorRegion.dataSource = dataSource # Get ready to run. net.initialize() # Train the network (by default learning is ON in the classifier, but assert # anyway) and then turn off learning and turn on inference mode. self.assertEqual(classifier.getParameter("learningMode"), 1) net.run(8) classifier.setParameter("inferenceMode", 1) classifier.setParameter("learningMode", 0) # Assert learning is OFF and that the classifier learned the dataset. self.assertEqual(classifier.getParameter("learningMode"), 0, "Learning mode is not turned off.") self.assertEqual(classifier.getParameter("inferenceMode"), 1, "Inference mode is not turned on.") self.assertEqual( classifier.getParameter("categoryCount"), 3, "The classifier should count three total categories.") # classififer learns 12 patterns b/c there are 12 categories amongst the # records: self.assertEqual( classifier.getParameter("patternCount"), 12, "The classifier should've learned 12 samples in total.") # Test the network on the same data as it trained on; should classify with # 100% accuracy. expectedCats = ([0.0, 0.5, 0.5], [0.0, 0.5, 0.5], [0.0, 0.5, 0.5], [0.5, 0.5, 0.0], [0.0, 0.5, 0.5], [0.0, 0.5, 0.5], [0.5, 0.5, 0.0], [0.0, 0.5, 0.5]) dataSource.rewind() for i in xrange(8): net.run(1) inferredCats = classifier.getOutputData("categoriesOut") self.assertSequenceEqual( expectedCats[i], inferredCats.tolist(), "Classififer did not infer expected category probabilites for record " "number {}.".format(i)) # Close data stream, delete file. dataSource.close() os.remove(filename)
def getDescription(datasets): encoder = MultiEncoder() encoder.addEncoder("date", DateEncoder(timeOfDay=3)) encoder.addEncoder("amount", LogEncoder(name="amount", maxval=1000)) for i in xrange(0, nRandomFields): s = ScalarEncoder(name="scalar", minval=0, maxval=randomFieldWidth, resolution=1, w=3) encoder.addEncoder("random%d" % i, s) dataSource = FunctionSource( generateFunction, dict(nRandomFields=nRandomFields, randomFieldWidth=randomFieldWidth)) inputShape = (1, encoder.getWidth()) # Layout the coincidences vertically stacked on top of each other, each # looking at the entire input field. coincidencesShape = (nCoincidences, 1) # TODO: why do we need input border? inputBorder = inputShape[1] / 2 if inputBorder * 2 >= inputShape[1]: inputBorder -= 1 nodeParams = dict() spParams = dict( commonDistributions=0, inputShape=inputShape, inputBorder=inputBorder, coincidencesShape=coincidencesShape, coincInputRadius=inputShape[1] / 2, coincInputPoolPct=0.75, gaussianDist=0, localAreaDensity=0.10, # localAreaDensity = 0.04, numActivePerInhArea=-1, dutyCyclePeriod=1000, stimulusThreshold=5, synPermInactiveDec=0.08, # synPermInactiveDec=0.02, synPermActiveInc=0.02, synPermActiveSharedDec=0.0, synPermOrphanDec=0.0, minPctDutyCycleBeforeInh=0.05, # minPctDutyCycleAfterInh = 0.1, # minPctDutyCycleBeforeInh = 0.05, minPctDutyCycleAfterInh=0.05, # minPctDutyCycleAfterInh = 0.4, seed=1, ) otherParams = dict( disableTemporal=1, trainingStep='spatial', ) nodeParams.update(spParams) nodeParams.update(otherParams) def mySetupCallback(experiment): print "Setup function called" description = dict( options=dict(logOutputsDuringInference=False, ), network=dict(sensorDataSource=dataSource, sensorEncoder=encoder, CLAType="py.CLARegion", CLAParams=nodeParams, classifierType=None, classifierParams=None), # step spTrain=dict( name="phase1", setup=mySetupCallback, iterationCount=5000, #iter=displaySPCoincidences(100), finish=printSPCoincidences()), tpTrain=None, # same format as sptrain if non-empty infer=None, # same format as sptrain if non-empty ) return description
def getDescriptionImpl(datasets, config): """ Implementation for description.py getDescription() entry point function. Builds an experiment description dictionary as required by LPF (Lightweight Prediction Framework). Hardcoded data that is less likely to vary between experiments is augmented with data from the config dictionary. See getBaseDatasets() and getDatasets(). datasets: a dictionary of input datasets that may have been pre-processed via aggregation. Keys: 'trainDataset' -- path to the training dataset 'inferDataset.N.alias' -- path(s) to the inference dataset config: configuration dictionary from description.py returns: an experiment description dictionary as required by LPF """ # ---------------------------------------------------------------------------- # Encoder for the sensor encoder = MultiEncoder(_getDatasetEncoderConfig(config)) # ------------------------------------------------------------------ # Region params CLAParams = _getCLAParams(encoder=encoder, config=config) sensorParams = dict( # encoder/datasource are not parameters so don't include here verbosity=config['sensorVerbosity']) # Filesource for the sensor. Set the filename in setup functions. dataSource = FileRecordStream('foo') description = dict( options=dict(logOutputsDuringInference=False, ), network=dict( # Think of sensor as a shell with dataSource and encoder; # Encoder has a pre-encoder and post-encoder filters; # filters appear in a different place (TODO: where?) sensorDataSource=dataSource, sensorEncoder=encoder, # LPF converts this to JSON strings; used as constructor args; has simple # types (ints, strings, floats) sensorParams=sensorParams, # CLA class; py. prefix for class names implemented in python; older code # implemented regions in C++ and designated class name without prefix. CLAType='py.CLARegion', # dict converted to JSON string CLAParams=CLAParams, # classifiers are presently not used (formerly used by vision code); should # be okay to leave out Classifier, sensor, CLA classifierType=None, classifierParams=None), ) # ---------------------------------------------------------------------------- # Configure Training and Inference phases # ---------------------------------------------------------------------------- # # phase is 0 or more steps (a list of dictionaries, each dict corresponds to one step) # (see py/nupic/frameworks/prediction/experiment.py docstring) # # step = dict (name, setup, iter, finish, iterationCount) # setup, iter, finish are callbacks; # # name: step name string; optional, used for printing messages to console # setup: open input file (e.g., via dataSource), print stats, etc. # iter: for diagnostics/debugging; called by net.run between iterations. # finish: called at the end by net.run; usually prints out stats (e.g., how many # synapses, time taken, etc.) # callbacks are almost always reused, so they are not experiment-specific (see # imports at top of file) # a callback always has this form c(experiment_obj, iter_number); can get # experiment.network.regions["sensor"].getSelf() spEnable = config['spEnable'] spTrain = _isSPTrainingEnabled(config) tpEnable = config['tpEnable'] tpTrain = _isTPTrainingEnabled(config) # NOTE: presently, we always train TP (during training phase) if TP is enabled assert (tpTrain == tpEnable) # At least one of SP/TP must be enabled for a meaningful system assert (spEnable or tpEnable) # NOTE: SP and Spatial regression need to undergo training over the same # set of rows. Since we're not reading the training dataset here to # find out the number of rows, we presently configure both with the # same auto-rewind setting. # TODO: this may cause knn training to repeatedly iterate unnecessarily # over the same records in case spTrainIterationCount is larger than the # nuber of rows in the training dataset. Look into optimizing this to # avoid wasting time on knn training due to unnecessary iterations, but # make sure that both SP and knn train on the exact same rows. spTrainMayNeedAutoRewind = True \ if config['spTrainIterationCount'] is not None \ else False # ---------------------------------------------------------------------------- # SP training if spTrain: description['spTrain'] = [] for i in xrange(config['spTrainNPasses']): stepDict = dict( name='sp.train.pass_%d' % (i), iterationCount=config['spTrainIterationCount'], setup=[sensorOpen(datasets[_getTrainingDatasetKey(config)]) if i==0 \ else sensorRewind, fileSourceAutoRewind(spTrainMayNeedAutoRewind),], finish=[fileSourceAutoRewind(False),], ) description['spTrain'].append(stepDict) elif spEnable: description['spTrain'] = dict( # need to train with one iteration just to initialize data structures # TODO: seems like a hack; shouldn't CLA framework automatically initialize # the necessary subsystems? (ask Ron) iterationCount=1, ) # ---------------------------------------------------------------------------- # TP training if tpTrain: description['tpTrain'] = [] mayNeedAutoRewind = True if config[ 'tpTrainIterationCount'] is not None else False for i in xrange(config['tpTrainNPasses']): stepDict = dict( name='tp.train.pass_%d' % (i), iterationCount=config['tpTrainIterationCount'], setup=[ sensorOpen(datasets[_getTrainingDatasetKey(config)]) if i==0 \ else sensorRewind, fileSourceAutoRewind(mayNeedAutoRewind), ], finish=[fileSourceAutoRewind(False),], ) if config['tpTrainPrintStatsPeriodIter'] > 0: stepDict['iter'] = printTPTiming( config['tpTrainPrintStatsPeriodIter']) stepDict['finish'] += [printTPTiming()] #, printTPCells] description['tpTrain'].append(stepDict) # ---------------------------------------------------------------------------- # Inference tests # NOTE: Presently, SP and TP learning is disabled during inference description['infer'] = [] predictionFields = None spatialRegrTests = None if 'spFieldPredictionSchema' in config and config[ 'spFieldPredictionSchema'] != None: if len(config['spFieldPredictionSchema']['predictionFields']) > 0: spFieldPredictionSchema = config['spFieldPredictionSchema'] predictionFields = spFieldPredictionSchema['predictionFields'] if len(spFieldPredictionSchema['regressionTests']) > 0: # presently, our spatial regression modules (knn and linear) don't support # multiple fields assert (len(predictionFields) == 1) spatialRegrTests = spFieldPredictionSchema['regressionTests'] # Set up test steps for all inference datasets for i, ds in enumerate(config['inferDatasets']): datasetInfo = config['inferDatasets'][i] # NOTE: the path/contents may differ from the corresponding dataset # referenced in config['inferDatasets'] due to preprocessing (e.g., # aggregation) inferenceDatasetKey = \ _datasetKeyFromInferenceDatasetIndex(index=i, config=config) inferenceDatasetPath = datasets[inferenceDatasetKey] # ---------------------------------------- # Step: Temporal inference # if tpEnable: # Turn off plot histograms when running under darwin plotTemporalHistograms = True if sys.platform.startswith('darwin'): plotTemporalHistograms = False print "Turning off plotTemporalHistograms under darwin" temporalTestingStep = dict( name=getTemporalInferenceStepName(datasetInfo['alias'], i), iterationCount=ds['iterCount'], setup=[sensorOpen(inferenceDatasetPath)], ppOptions=dict( verbosity=config['postprocVerbosity'], plotTemporalHistograms=plotTemporalHistograms, printLearnedCoincidences=False, logPredictions=True, )) description['infer'].append(temporalTestingStep) else: print 'temporalTestingStep skipped.' # ---------------------------------------- # Step: Non-temporal Regression algorithm training (if enabled) # if spatialRegrTests: # NOTE: we don't need auto-rewind when training spatial regression algorithms regrTrainStep = dict( name = ('%s_nontemporal.training') % \ (_normalizeDatasetAliasNameForStepName(datasetInfo['alias']),), iterationCount=config['spTrainIterationCount'], setup=[sensorOpen(datasets[_getTrainingDatasetKey(config)]), fileSourceAutoRewind(spTrainMayNeedAutoRewind),], ppOptions = dict(verbosity=config['postprocVerbosity'], printLearnedCoincidences=False,) ) # Add Spatial Regression algorithm training requests ppOptions = regrTrainStep['ppOptions'] for test in spatialRegrTests: assert (len(predictionFields) == 1) ppOptions[ test['algorithm']] = 'train,%s' % (predictionFields[0]) description['infer'].append(regrTrainStep) # ---------------------------------------- # Step: Non-temporal Inference # nontemporalTestingStep = dict( name=getNonTemporalInferenceStepName(datasetInfo['alias'], i), iterationCount=ds['iterCount'], setup=[ sensorOpen(inferenceDatasetPath), fileSourceAutoRewind(False), # TODO Do we need to turn off collectStats in the 'finish' sub-step? setTPAttribute('collectStats', 1), ], # TODO which ppOptions do we want in this template? ppOptions=dict( verbosity=config['postprocVerbosity'], plotTemporalHistograms=False, printLearnedCoincidences=False, logPredictions=True, ), ) # Add Spatial Field Prediction options to inference step if predictionFields: # Set sparse encodings of prediction fields to zero setup = nontemporalTestingStep['setup'] setup.append( setAttribute('sensor', 'postEncodingFilters', [ ModifyFields(fields=predictionFields, operation='setToZero') ])) if spatialRegrTests: # Add regression test requests ppOptions = nontemporalTestingStep['ppOptions'] for test in spatialRegrTests: assert (len(predictionFields) == 1) ppOptions[ test['algorithm']] = 'test,%s' % (predictionFields[0]) description['infer'].append(nontemporalTestingStep) # ---------------------------------------------------------------------------- # Add auto-reset intervals to the sensor region for tpTrain and Infer phases # (if config['sensorAutoReset'] is enabled) # ---------------------------------------------------------------------------- if 'sensorAutoReset' in config and config['sensorAutoReset'] is not None: dd = defaultdict(lambda: 0, config['sensorAutoReset']) # class timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, # hours[, weeks]]]]]]]) if not (0 == dd['days'] == dd['hours'] == dd['minutes'] == dd['seconds'] \ == dd['milliseconds'] == dd['microseconds'] == dd['weeks']): timeDelta = timedelta(days=dd['days'], hours=dd['hours'], minutes=dd['minutes'], seconds=dd['seconds'], milliseconds=dd['milliseconds'], microseconds=dd['microseconds'], weeks=dd['weeks']) tpTrainSteps = description[ 'tpTrain'] if 'tpTrain' in description else [] inferSteps = description['infer'] if 'infer' in description else [] for step in itertools.chain(tpTrainSteps, inferSteps): if 'setup' not in step: step['setup'] = [] step['setup'].append(setAutoResetInterval(timeDelta)) return description
def createTemporalAnomaly(recordParams, spatialParams=_SP_PARAMS, temporalParams=_TP_PARAMS, verbosity=_VERBOSITY): """Generates a Network with connected RecordSensor, SP, TP. This function takes care of generating regions and the canonical links. The network has a sensor region reading data from a specified input and passing the encoded representation to an SPRegion. The SPRegion output is passed to a TPRegion. Note: this function returns a network that needs to be initialized. This allows the user to extend the network by adding further regions and connections. :param recordParams: a dict with parameters for creating RecordSensor region. :param spatialParams: a dict with parameters for creating SPRegion. :param temporalParams: a dict with parameters for creating TPRegion. :param verbosity: an integer representing how chatty the network will be. """ inputFilePath = recordParams["inputFilePath"] scalarEncoderArgs = recordParams["scalarEncoderArgs"] dateEncoderArgs = recordParams["dateEncoderArgs"] scalarEncoder = ScalarEncoder(**scalarEncoderArgs) dateEncoder = DateEncoder(**dateEncoderArgs) encoder = MultiEncoder() encoder.addEncoder(scalarEncoderArgs["name"], scalarEncoder) encoder.addEncoder(dateEncoderArgs["name"], dateEncoder) network = Network() network.addRegion("sensor", "py.RecordSensor", json.dumps({"verbosity": verbosity})) sensor = network.regions["sensor"].getSelf() sensor.encoder = encoder sensor.dataSource = FileRecordStream(streamID=inputFilePath) # Create the spatial pooler region spatialParams["inputWidth"] = sensor.encoder.getWidth() network.addRegion("spatialPoolerRegion", "py.SPRegion", json.dumps(spatialParams)) # Link the SP region to the sensor input network.link("sensor", "spatialPoolerRegion", "UniformLink", "") network.link("sensor", "spatialPoolerRegion", "UniformLink", "", srcOutput="resetOut", destInput="resetIn") network.link("spatialPoolerRegion", "sensor", "UniformLink", "", srcOutput="spatialTopDownOut", destInput="spatialTopDownIn") network.link("spatialPoolerRegion", "sensor", "UniformLink", "", srcOutput="temporalTopDownOut", destInput="temporalTopDownIn") # Add the TPRegion on top of the SPRegion network.addRegion("temporalPoolerRegion", "py.TPRegion", json.dumps(temporalParams)) network.link("spatialPoolerRegion", "temporalPoolerRegion", "UniformLink", "") network.link("temporalPoolerRegion", "spatialPoolerRegion", "UniformLink", "", srcOutput="topDownOut", destInput="topDownIn") spatialPoolerRegion = network.regions["spatialPoolerRegion"] # Make sure learning is enabled spatialPoolerRegion.setParameter("learningMode", True) # We want temporal anomalies so disable anomalyMode in the SP. This mode is # used for computing anomalies in a non-temporal model. spatialPoolerRegion.setParameter("anomalyMode", False) temporalPoolerRegion = network.regions["temporalPoolerRegion"] # Enable topDownMode to get the predicted columns output temporalPoolerRegion.setParameter("topDownMode", True) # Make sure learning is enabled (this is the default) temporalPoolerRegion.setParameter("learningMode", True) # Enable inference mode so we get predictions temporalPoolerRegion.setParameter("inferenceMode", True) # Enable anomalyMode to compute the anomaly score. temporalPoolerRegion.setParameter("anomalyMode", True) return network
def createEncoder(): volume_encoder = ScalarEncoder(21, 0.0, 20.0, n=200, name="volume", clipInput=False) floorheight_encoder = ScalarEncoder(21, 0.0, 24.0, n=125, name="floorheight", clipInput=False) diagCoorA_encoder = ScalarEncoder(21, 0.0, 200.0, n=200, name="diagCoorA", clipInput=False) diagCoorB_encoder = ScalarEncoder(21, 0.0, 200.0, n=200, name="diagCoorB", clipInput=False) diagCoorC_encoder = ScalarEncoder(21, 0.0, 200.0, n=200, name="diagCoorC", clipInput=False) diagCoorD_encoder = ScalarEncoder(21, 0.0, 200.0, n=200, name="diagCoorD", clipInput=False) diagCoorE_encoder = ScalarEncoder(21, 0.0, 200.0, n=200, name="diagCoorE", clipInput=False) diagCoorF_encoder = ScalarEncoder(21, 0.0, 200.0, n=200, name="diagCoorF", clipInput=False) diagCoorG_encoder = ScalarEncoder(21, 0.0, 200.0, n=200, name="diagCoorG", clipInput=False) diagCoorH_encoder = ScalarEncoder(21, 0.0, 200.0, n=200, name="diagCoorH", clipInput=False) diagCoorI_encoder = ScalarEncoder(21, 0.0, 200.0, n=200, name="diagCoorI", clipInput=False) diagCoorJ_encoder = ScalarEncoder(21, 0.0, 200.0, n=200, name="diagCoorJ", clipInput=False) global encoder encoder = MultiEncoder() encoder.addEncoder("volume", volume_encoder) encoder.addEncoder("floorheight", floorheight_encoder) encoder.addEncoder("diagCoorA", diagCoorA_encoder) encoder.addEncoder("diagCoorB", diagCoorB_encoder) encoder.addEncoder("diagCoorC", diagCoorC_encoder) encoder.addEncoder("diagCoorD", diagCoorD_encoder) encoder.addEncoder("diagCoorE", diagCoorE_encoder) encoder.addEncoder("diagCoorF", diagCoorF_encoder) encoder.addEncoder("diagCoorG", diagCoorG_encoder) encoder.addEncoder("diagCoorH", diagCoorH_encoder) encoder.addEncoder("diagCoorI", diagCoorI_encoder) encoder.addEncoder("diagCoorJ", diagCoorJ_encoder) return encoder
def createTemporalAnomaly_chemical(recordParams, spatialParams, temporalParams, verbosity): inputFilePath = recordParams["inputFilePath"] scalarEncoder1Args = recordParams["scalarEncoder1Args"] scalarEncoder2Args = recordParams["scalarEncoder2Args"] scalarEncoder3Args = recordParams["scalarEncoder3Args"] scalarEncoder4Args = recordParams["scalarEncoder4Args"] scalarEncoder5Args = recordParams["scalarEncoder5Args"] scalarEncoder6Args = recordParams["scalarEncoder6Args"] scalarEncoder7Args = recordParams["scalarEncoder7Args"] dateEncoderArgs = recordParams["dateEncoderArgs"] scalarEncoder1 = ScalarEncoder(**scalarEncoder1Args) scalarEncoder2 = ScalarEncoder(**scalarEncoder2Args) scalarEncoder3 = ScalarEncoder(**scalarEncoder3Args) scalarEncoder4 = ScalarEncoder(**scalarEncoder4Args) scalarEncoder5 = ScalarEncoder(**scalarEncoder5Args) scalarEncoder6 = ScalarEncoder(**scalarEncoder6Args) scalarEncoder7 = ScalarEncoder(**scalarEncoder7Args) dateEncoder = DateEncoder(**dateEncoderArgs) encoder = MultiEncoder() encoder.addEncoder(scalarEncoder1Args["name"], scalarEncoder1) encoder.addEncoder(scalarEncoder2Args["name"], scalarEncoder2) encoder.addEncoder(scalarEncoder3Args["name"], scalarEncoder3) encoder.addEncoder(scalarEncoder4Args["name"], scalarEncoder4) encoder.addEncoder(scalarEncoder5Args["name"], scalarEncoder5) encoder.addEncoder(scalarEncoder6Args["name"], scalarEncoder6) encoder.addEncoder(scalarEncoder7Args["name"], scalarEncoder7) encoder.addEncoder(dateEncoderArgs["name"], dateEncoder) network = Network() network.addRegion("sensor", "py.RecordSensor", json.dumps({"verbosity": verbosity})) sensor = network.regions["sensor"].getSelf() sensor.encoder = encoder sensor.dataSource = FileRecordStream(streamID=inputFilePath) # Create the spatial pooler region spatialParams["inputWidth"] = sensor.encoder.getWidth() network.addRegion("spatialPoolerRegion", "py.SPRegion", json.dumps(spatialParams)) # Link the SP region to the sensor input network.link("sensor", "spatialPoolerRegion", "UniformLink", "") network.link("sensor", "spatialPoolerRegion", "UniformLink", "", srcOutput="resetOut", destInput="resetIn") network.link("spatialPoolerRegion", "sensor", "UniformLink", "", srcOutput="spatialTopDownOut", destInput="spatialTopDownIn") network.link("spatialPoolerRegion", "sensor", "UniformLink", "", srcOutput="temporalTopDownOut", destInput="temporalTopDownIn") # Add the TPRegion on top of the SPRegion network.addRegion("temporalPoolerRegion", "py.TMRegion", json.dumps(temporalParams)) network.link("spatialPoolerRegion", "temporalPoolerRegion", "UniformLink", "") network.link("temporalPoolerRegion", "spatialPoolerRegion", "UniformLink", "", srcOutput="topDownOut", destInput="topDownIn") # Add the AnomalyLikelihoodRegion on top of the TMRegion network.addRegion("anomalyLikelihoodRegion", "py.AnomalyLikelihoodRegion", json.dumps({})) network.link("temporalPoolerRegion", "anomalyLikelihoodRegion", "UniformLink", "", srcOutput="anomalyScore", destInput="rawAnomalyScore") network.link("sensor", "anomalyLikelihoodRegion", "UniformLink", "", srcOutput="sourceOut", destInput="metricValue") spatialPoolerRegion = network.regions["spatialPoolerRegion"] # Make sure learning is enabled spatialPoolerRegion.setParameter("learningMode", True) # We want temporal anomalies so disable anomalyMode in the SP. This mode is # used for computing anomalies in a non-temporal model. spatialPoolerRegion.setParameter("anomalyMode", False) temporalPoolerRegion = network.regions["temporalPoolerRegion"] # Enable topDownMode to get the predicted columns output temporalPoolerRegion.setParameter("topDownMode", True) # Make sure learning is enabled (this is the default) temporalPoolerRegion.setParameter("learningMode", True) # Enable inference mode so we get predictions temporalPoolerRegion.setParameter("inferenceMode", True) # Enable anomalyMode to compute the anomaly score. temporalPoolerRegion.setParameter("anomalyMode", True) return network