def testVaryingNumberOfCategories(self): # Setup network with sensor; max number of categories = 2 net = Network() sensorRegion = net.addRegion("sensor", "py.RecordSensor", "{'numCategories': 2}") sensor = sensorRegion.getSelf() # Test for # of output categories = max data = { "_timestamp": None, "_category": [0, 1], "label": "0 1", "_sequenceId": 0, "y": 2.624902024, "x": 0.0, "_timestampRecordIdx": None, "_reset": 0 } sensorOutput = numpy.array([0, 0], dtype="int32") sensor.populateCategoriesOut(data["_category"], sensorOutput) self.assertSequenceEqual([0, 1], sensorOutput.tolist( ), "Sensor failed to populate the array with record of two categories." ) # Test for # of output categories > max data["_category"] = [1, 2, 3] sensorOutput = numpy.array([0, 0], dtype="int32") sensor.populateCategoriesOut(data["_category"], sensorOutput) self.assertSequenceEqual([1, 2], sensorOutput.tolist( ), "Sensor failed to populate the array w/ record of three categories." ) # Test for # of output categories < max data["_category"] = [3] sensorOutput = numpy.array([0, 0], dtype="int32") sensor.populateCategoriesOut(data["_category"], sensorOutput) self.assertSequenceEqual( [3, -1], sensorOutput.tolist(), "Sensor failed to populate the array w/ record of one category.") # Test for no output categories data["_category"] = [None] sensorOutput = numpy.array([0, 0], dtype="int32") sensor.populateCategoriesOut(data["_category"], sensorOutput) self.assertSequenceEqual([-1, -1], sensorOutput.tolist( ), "Sensor failed to populate the array w/ record of zero categories.")
def __init__(self, model_params): # Init an HTM network self.network = Network() # Getting parameters for network regions self.sensor_params = model_params['Sensor'] self.spatial_pooler_params = model_params['SpatialPooler'] self.temporal_memory_params = model_params['TemporalMemory'] self.classifiers_params = model_params['Classifiers'] self.encoders_params = model_params['Encoders'] # Adding regions to HTM network self.network.addRegion('DurationEncoder', 'ScalarSensor', json.dumps(self.encoders_params['duration'])) self.network.addRegion('VelocityEncoder', 'ScalarSensor', json.dumps(self.encoders_params['pitch'])) self.network.addRegion('PitchEncoder', 'ScalarSensor', json.dumps(self.encoders_params['velocity'])) self.network.addRegion('SpatialPooler', 'py.SPRegion', json.dumps(self.spatial_pooler_params)) self.network.addRegion('TemporalMemory', 'py.TMRegion', json.dumps(self.temporal_memory_params)) # Creating outer classifiers for multifield prediction dclp = self.classifiers_params['duration'] vclp = self.classifiers_params['pitch'] pclp = self.classifiers_params['velocity'] self.duration_classifier = SDRClassifier( steps=(1, ), verbosity=dclp['verbosity'], alpha=dclp['alpha'], actValueAlpha=dclp['actValueAlpha']) self.velocity_classifier = SDRClassifier( steps=(1, ), verbosity=vclp['verbosity'], alpha=vclp['alpha'], actValueAlpha=vclp['actValueAlpha']) self.pitch_classifier = SDRClassifier( steps=(1, ), verbosity=pclp['verbosity'], alpha=pclp['alpha'], actValueAlpha=pclp['actValueAlpha']) self._link_all_regions() self._enable_learning() self._enable_inference() self.network.initialize()
def _deSerializeExtraData(self, extraDataDir): """ Protected method that is called during deserialization (after __setstate__) with an external directory path. We override it here to load the Network API instance. @param extraDataDir (string) Model's extra data directory path """ # Must call this before loading any regions in the research repo registerAllResearchRegions() self.network = Network(os.path.join(extraDataDir, "network.nta")) self._initializeRegionHelpers()
def plotPermanences(network = None, savedNetworkFile = "mnist_net.nta", columnList = None, iteration=0): """ Plots the permanences of the top columns into a single master image If columnList is specified, uses those columns otherwise extracts the most active columns from the spatial pooler using duty cycle. """ # Get the spatial pooler from the network, otherwise read it from checkpoint. if network is None: network = Network(savedNetworkFile) spRegion = network.regions["SP"] spSelf = spRegion.getSelf() sp = spSelf._sfdr # If we are not given a column list, retrieve columns with highest duty cycles dutyCycles = numpy.zeros(sp.getNumColumns(), dtype=GetNTAReal()) sp.getActiveDutyCycles(dutyCycles) if columnList is None: mostActiveColumns = list(dutyCycles.argsort()) mostActiveColumns.reverse() columnList = mostActiveColumns[0:400] #print columnList # Create empty master image with the top 25 columns. We will paste # individual column images into this image numImagesPerRowInMaster = 20 masterImage = Image.new("L",((32+2)*numImagesPerRowInMaster, (32+2)*numImagesPerRowInMaster),255) for rank,col in enumerate(columnList): #print "Col=",col,"rank=",rank,"dutyCycle=",dutyCycles[col] pyPerm = numpy.zeros(sp.getNumInputs(), dtype=GetNTAReal()) sp.getPermanence(col,pyPerm) # Create small image for each column pyPerm = pyPerm/pyPerm.max() pyPerm = (pyPerm*255.0) pyPerm = pyPerm.reshape((32,32)) pyPerm = (pyPerm).astype('uint8') img = Image.fromarray(pyPerm) # Paste it into master image if rank < numImagesPerRowInMaster*numImagesPerRowInMaster: x = rank%numImagesPerRowInMaster*(32+2) y = (rank/numImagesPerRowInMaster)*(32+2) masterImage.paste(img,(x,y)) # Save master image masterImage.save("master_%05d.png"%(iteration))
def testParameters(self): # Test setting and getting parameters net = Network() # Add sensor to the network sensor = net.addRegion("sensor", "py.ImageSensor", "{width: 100, height: 50}") # Verify get parameters self.assertEqual(sensor.getParameter('height'), 50) self.assertEqual(sensor.getParameter('width'), 100) # Verify set parameters sensor.setParameter('width', 42) self.assertEqual(sensor.getParameter('width'), 42)
def createNetwork(networkConfig): """ Create and initialize the specified network instance. @param networkConfig: (dict) the configuration of this network. @return network: (Network) The actual network """ registerAllResearchRegions() network = Network() if networkConfig["networkType"] == "L4L2Column": return createL4L2Column(network, networkConfig, "_0") elif networkConfig["networkType"] == "MultipleL4L2Columns": return createMultipleL4L2Columns(network, networkConfig)
def createAnomalyNetwork(dataSource): network = Network() #sensor region network.addRegion("sensor", "py.RecordSensor", json.dumps({"verbosity": _VERBOSITY})) #encoder setup sensorRegion = network.regions["sensor"].getSelf() sensorRegion.encoder = createEncoder() sensorRegion.dataSource = dataSource #SP width must have sensor output width SP_PARAMS["inputWidth"] = sensorRegion.encoder.getWidth() #Add SP and TM regions network.addRegion("SP", "py.SPRegion", json.dumps(SP_PARAMS)) network.link("sensor", "SP", "UniformLink", "") network.link("sensor", "SP", "UniformLink", "", srcOutput="resetOut", destInput="resetIn") network.link("SP", "sensor", "UniformLink", "", srcOutput="spatialTopDownOut", destInput="spatialTopDownIn") network.link("SP", "sensor","UniformLink", "", srcOutput ="temporalTopDownOut", destInput="temporalTopDownIn") network.addRegion("TM", "py.TMRegion", json.dumps(TM_PARAMS)) network.link("SP", "TM", "UniformLink", "") network.link("TM", "SP", "UniformLink", "", srcOutput="topDownOut", destInput="topDownIn") #Add anomalyLikeliHood network.addRegion("ALH", "py.AnomalyLikelihoodRegion", json.dumps({})) network.link("TM", "ALH", "UniformLink", "", srcOutput="anomalyScore", destInput="rawAnomalyScore") network.link("sensor", "ALH", "UniformLink", "", srcOutput="sourceOut", destInput="metricValue") #set layer parameters spRegion = network.regions["SP"] spRegion.setParameter("learningMode", True) spRegion.setParameter("anomalyMode", False) tmRegion = network.regions["TM"] tmRegion.setParameter("topDownMode", True) tmRegion.setParameter("learningMode", True) tmRegion.setParameter("inferenceMode", True) tmRegion.setParameter("anomalyMode", True) return network
def testSaveAndReload(self): """ This function tests saving and loading. It will train a network for 500 iterations, then save it and reload it as a second network instance. It will then run both networks for 100 iterations and ensure they return identical results. """ print "Creating network..." netOPF = _createOPFNetwork() level1OPF = netOPF.regions['level1SP'] # ========================================================================== print "Training network for 500 iterations" level1OPF.setParameter('learningMode', 1) level1OPF.setParameter('inferenceMode', 0) netOPF.run(500) level1OPF.setParameter('learningMode', 0) level1OPF.setParameter('inferenceMode', 1) # ========================================================================== # Save network and reload as a second instance. We need to reset the data # source for the unsaved network so that both instances start at the same # place print "Saving and reload network" _, tmpNetworkFilename = _setupTempDirectory("trained.nta") netOPF.save(tmpNetworkFilename) netOPF2 = Network(tmpNetworkFilename) level1OPF2 = netOPF2.regions['level1SP'] sensor = netOPF.regions['sensor'].getSelf() trainFile = resource_filename("nupic.datafiles", "extra/gym/gym.csv") sensor.dataSource = FileRecordStream(streamID=trainFile) sensor.dataSource.setAutoRewind(True) # ========================================================================== print "Running inference on the two networks for 100 iterations" for _ in xrange(100): netOPF2.run(1) netOPF.run(1) l1outputOPF2 = level1OPF2.getOutputData("bottomUpOut") l1outputOPF = level1OPF.getOutputData("bottomUpOut") opfHash2 = l1outputOPF2.nonzero()[0].sum() opfHash = l1outputOPF.nonzero()[0].sum() self.assertEqual(opfHash2, opfHash)
def createNetwork(dataSource): ''' Create and initialize a network. ''' with open(_PARAMS_PATH, "r") as f: modelParams = yaml.safe_load(f)["modelParams"] # Create a network that will hold the regions. network = Network() # Add a sensor region. network.addRegion("sensor", "py.RecordSensor", "{}") # Set the encoder and data source of the sensor region. sensorRegion = network.regions["sensor"].getSelf() sensorRegion.encoder = createEncoder( modelParams["sensorParams"]["encoders"]) sensorRegion.dataSource = dataSource # Make sure the SP input width matches the sensor region output width. modelParams["spParams"]["inputWidth"] = sensorRegion.encoder.getWidth() # Add SP and TP regions. network.addRegion("SP", "py.SPRegion", json.dumps(modelParams["spParams"])) network.addRegion("TM", "py.TMRegion", json.dumps(modelParams["tmParams"])) # Add a classifier region. clName = "py.%s" % modelParams["clParams"].pop("regionName") network.addRegion("classifier", clName, json.dumps(modelParams["clParams"])) classifierRegion = network.regions["classifier"].getSelf() # Add all links createSensorToClassifierLinks(network, "sensor", "classifier") createDataOutLink(network, "sensor", "SP") createFeedForwardLink(network, "SP", "TM") createFeedForwardLink(network, "TM", "classifier") # Reset links are optional, since the sensor region does not send resets. createResetLink(network, "sensor", "SP") createResetLink(network, "sensor", "TM") # Make sure all objects are initialized. network.initialize() return network
def createNetwork(dataSource): """Create the Network instance. The network has a sensor region reading data from `dataSource` and passing the encoded representation to an Identity Region. :param dataSource: a RecordStream instance to get data from :returns: a Network instance ready to run """ network = Network() # Our input is sensor data from the gym file. The RecordSensor region # allows us to specify a file record stream as the input source via the # dataSource attribute. network.addRegion("sensor", "py.RecordSensor", json.dumps({"verbosity": _VERBOSITY})) sensor = network.regions["sensor"].getSelf() # The RecordSensor needs to know how to encode the input values sensor.encoder = createEncoder() # Specify the dataSource as a file record stream instance sensor.dataSource = dataSource # CUSTOM REGION # Add path to custom region to PYTHONPATH # NOTE: Before using a custom region, please modify your PYTHONPATH # export PYTHONPATH="<path to custom region module>:$PYTHONPATH" # In this demo, we have modified it using sys.path.append since we need it to # have an effect on this program. sys.path.append(os.path.dirname(os.path.abspath(__file__))) from custom_region.identity_region import IdentityRegion # Add custom region class to the network Network.registerRegion(IdentityRegion) # Create a custom region network.addRegion("identityRegion", "py.IdentityRegion", json.dumps({ "dataWidth": sensor.encoder.getWidth(), })) # Link the Identity region to the sensor output network.link("sensor", "identityRegion", "UniformLink", "") network.initialize() return network
def create_network(): network = Network() m_sensor = network.addRegion("Measurement", 'ScalarSensor', json.dumps(_SCALAR_ENCODER)) dt_sensor = network.addRegion("DT", 'py.PluggableEncoderSensor', "") dt_sensor.getSelf().encoder = DateEncoder(**_DATE_ENCODER) # Add a SPRegion, a region containing a spatial pooler scalar_n = m_sensor.getParameter('n') dt_n = dt_sensor.getSelf().encoder.getWidth() _SP_PARAMS["inputWidth"] = scalar_n + dt_n network.addRegion("sp", "py.SPRegion", json.dumps(_SP_PARAMS)) # Input to the Spatial Pooler network.link("Measurement", "sp", "UniformLink", "") network.link("DT", "sp", "UniformLink", "") # Add a TPRegion, a region containing a Temporal Memory network.addRegion("tm", "py.TMRegion", json.dumps(_TM_PARAMS)) # Set up links network.link("sp", "tm", "UniformLink", "") network.link("tm", "sp", "UniformLink", "", srcOutput="topDownOut", destInput="topDownIn") network.regions['sp'].setParameter("learningMode", True) network.regions['sp'].setParameter("anomalyMode", False) # network.regions['tm'].setParameter("topDownMode", True) # check this # Make sure learning is enabled (this is the default) network.regions['tm'].setParameter("learningMode", True) # Enable anomalyMode so the tm calculates anomaly scores network.regions['tm'].setParameter("anomalyMode", True) # Enable inference mode to be able to get predictions network.regions['tm'].setParameter("inferenceMode", True) # TODO: enable all inferences return network
def createNetwork(): network = Network() # # Sensors # # C++ consumptionSensor = network.addRegion( 'consumptionSensor', 'ScalarSensor', json.dumps({ 'n': 120, 'w': 21, 'minValue': 0.0, 'maxValue': 100.0, 'clipInput': True })) return network
def loadFromFile(self, filename): """ Load a serialized network :param filename: Where the network should be loaded from """ print "Loading network from {file}...".format(file=filename) Network.unregisterRegion(SaccadeSensor.__name__) Network.registerRegion(SaccadeSensor) Network.registerRegion(ExtendedTMRegion) self.net = Network(filename) self.networkSensor = self.net.regions["sensor"] self.networkSensor.setParameter("numSaccades", SACCADES_PER_IMAGE_TESTING) self.networkSP = self.net.regions["SP"] self.networkClassifier = self.net.regions["classifier"] self.numCorrect = 0
def testOverlap(self): """Create a simple network to test the region.""" rawParams = {"outputWidth": 8 * 2048} net = Network() rawSensor = net.addRegion("raw", "py.RawSensor", json.dumps(rawParams)) l2c = net.addRegion("L2", "py.ColumnPoolerRegion", "") net.link("raw", "L2", "UniformLink", "") self.assertEqual(rawSensor.getParameter("outputWidth"), l2c.getParameter("inputWidth"), "Incorrect outputWidth parameter") rawSensorPy = rawSensor.getSelf() rawSensorPy.addDataToQueue([2, 4, 6], 0, 42) rawSensorPy.addDataToQueue([2, 42, 1023], 1, 43) rawSensorPy.addDataToQueue([18, 19, 20], 0, 44) # Run the network and check outputs are as expected net.run(3)
def testLoadImages(self): # Create a simple network with an ImageSensor. You can't actually run # the network because the region isn't connected to anything net = Network() Network.registerRegion(ImageSensor) net.addRegion("sensor", "py.ImageSensor", "{width: 32, height: 32}") sensor = net.regions['sensor'] # Create a dataset with two categories, one image in each category # Each image consists of a unique rectangle tmpDir = tempfile.mkdtemp() os.makedirs(os.path.join(tmpDir, '0')) os.makedirs(os.path.join(tmpDir, '1')) im0 = Image.new("L", (32, 32)) draw = ImageDraw.Draw(im0) draw.rectangle((10, 10, 20, 20), outline=255) im0.save(os.path.join(tmpDir, '0', 'im0.png')) im1 = Image.new("L", (32, 32)) draw = ImageDraw.Draw(im1) draw.rectangle((15, 15, 25, 25), outline=255) im1.save(os.path.join(tmpDir, '1', 'im1.png')) # Load the dataset and check we loaded the correct number sensor.executeCommand(["loadMultipleImages", tmpDir]) numImages = sensor.getParameter('numImages') self.assertEqual(numImages, 2) # Load a single image (this will replace the previous images) sensor.executeCommand( ["loadSingleImage", os.path.join(tmpDir, '1', 'im1.png')]) numImages = sensor.getParameter('numImages') self.assertEqual(numImages, 1) # Cleanup the temp files os.unlink(os.path.join(tmpDir, '0', 'im0.png')) os.unlink(os.path.join(tmpDir, '1', 'im1.png')) os.removedirs(os.path.join(tmpDir, '0')) os.removedirs(os.path.join(tmpDir, '1'))
def createNetwork(): """ Set up the following simple network and return it: ImageSensorRegion -> SP -> KNNClassifier Region """ net = Network() # Add the three regions net.addRegion("sensor", "py.ImageSensor", json.dumps(DEFAULT_IMAGESENSOR_PARAMS)) net.addRegion("SP", "py.SPRegion", json.dumps(DEFAULT_SP_PARAMS)) net.addRegion("classifier", "py.KNNClassifierRegion", json.dumps(DEFAULT_CLASSIFIER_PARAMS)) # Link up the regions. Note that we need to create a link from the sensor # to the classifier to send in the category labels. net.link("sensor", "SP", "UniformLink", "", srcOutput="dataOut", destInput="bottomUpIn") net.link("SP", "classifier", "UniformLink", "", srcOutput="bottomUpOut", destInput="bottomUpIn") net.link("sensor", "classifier", "UniformLink", "", srcOutput="categoryOut", destInput="categoryIn") # Make sure all objects are initialized net.initialize() return net
def _createLPFNetwork(addSP=True, addTP=False): """Create an 'old-style' network ala LPF and return it.""" # ========================================================================== # Create the encoder and data source stuff we need to configure the sensor sensorParams = dict(verbosity=_VERBOSITY) encoder = _createEncoder() trainFile = findDataset("extra/gym/gym.csv") dataSource = FileRecordStream(streamID=trainFile) dataSource.setAutoRewind(True) # Create all the stuff we need to configure the CLARegion g_claConfig['spEnable'] = addSP g_claConfig['tpEnable'] = addTP claParams = _getCLAParams(encoder=encoder, config=g_claConfig) claParams['spSeed'] = g_claConfig['spSeed'] claParams['tpSeed'] = g_claConfig['tpSeed'] # ========================================================================== # Now create the network itself n = Network() n.addRegion("sensor", "py.RecordSensor", json.dumps(sensorParams)) sensor = n.regions['sensor'].getSelf() sensor.encoder = encoder sensor.dataSource = dataSource n.addRegion("level1", "py.CLARegion", json.dumps(claParams)) n.link("sensor", "level1", "UniformLink", "") n.link("sensor", "level1", "UniformLink", "", srcOutput="resetOut", destInput="resetIn") return n
def createNetwork(args): """ Create the network instance with regions for the sensor, SP, TM, and classifier. Before running, be sure to init w/ network.initialize(). @param args (dataSource, sensorType, encoders), more info: dataSource (RecordStream) Sensor region reads data from here. sensorType (str) Specific type of region, e.g. "py.RecordSensor"; possible options can be found in nupic/regions/. classifierType (str) Specific type of classifier region, e.g. "py.CLAClassifier"; possible options can be found in nupic/regions/. encoders (dict) See createEncoder() docstring for format. @return (Network) sensor -> SP -> TM -> CLA classifier """ network = Network() createRegions(network, args) linkRegions(network) return network
def inspect(element, showRun=True, icon=None): """ Launch an Inspector for the provided element. element -- A network, region or a path to a network directory. showRun -- Whether to show the RuntimeInspector in the dropdown, which lets the user run the network. """ if isinstance(element, basestring): element = Network(element) else: assert isinstance(element, Network) if len(element.regions) == 0: raise Exception('Unable to inspect an empty network') # Network must be initialized before it can be inspected element.initialize() from wx import GetApp, PySimpleApp if GetApp(): useApp = True else: useApp = False from nupic.analysis.inspectors.MultiInspector import MultiInspector if not useApp: app = PySimpleApp() inspector = MultiInspector(element=element, showRun=showRun, icon=icon) if not useApp: app.MainLoop() app.Destroy() else: return inspector
def testNetwork(testPath="mnist/testing", savedNetworkFile="mnist_net.nta"): net = Network(savedNetworkFile) sensor = net.regions["sensor"] sp = net.regions["SP"] classifier = net.regions["classifier"] print "Reading test images" sensor.executeCommand(["loadMultipleImages", testPath]) numTestImages = sensor.getParameter("numImages") print "Number of test images", numTestImages start = time.time() # Various region parameters sensor.setParameter("explorer", yaml.dump(["RandomFlash", { "replacement": False }])) classifier.setParameter("inferenceMode", 1) classifier.setParameter("learningMode", 0) sp.setParameter("inferenceMode", 1) sp.setParameter("learningMode", 0) numCorrect = 0 for i in range(numTestImages): net.run(1) inferredCategory = classifier.getOutputData("categoriesOut").argmax() if sensor.getOutputData("categoryOut") == inferredCategory: numCorrect += 1 if i % (numTestImages / 100) == 0: print "Iteration", i, "numCorrect=", numCorrect # Some interesting statistics print "Testing time:", time.time() - start print "Number of test images", numTestImages print "num correct=", numCorrect print "pct correct=", (100.0 * numCorrect) / numTestImages
def main(): # Create Network instance network = Network() # Add three TestNode regions to network network.addRegion("region1", "TestNode", "") network.addRegion("region2", "TestNode", "") network.addRegion("region3", "TestNode", "") # Set dimensions on first region region1 = network.getRegions().getByName("region1") region1.setDimensions(Dimensions([1, 1])) # Link regions network.link("region1", "region2", "UniformLink", "") network.link("region2", "region1", "UniformLink", "") network.link("region1", "region3", "UniformLink", "") network.link("region2", "region3", "UniformLink", "") # Initialize network network.initialize() # Initialize Network Visualizer viz = NetworkVisualizer(network) # Render w/ graphviz viz.render(renderer=GraphVizRenderer) # Render w/ networkx viz.render(renderer=NetworkXRenderer) # Render to dot (stdout) viz.render(renderer=DotRenderer) # Render to dot (file) viz.render(renderer=lambda: DotRenderer(open("example.dot", "w")))
def getOutputElementCount(self, outputName): """Returns the width of dataOut.""" # Check if classifier has a 'maxCategoryCount' attribute if not hasattr(self, "maxCategoryCount"): # Large default value for backward compatibility self.maxCategoryCount = 1000 if outputName == "categoriesOut": return len(self.stepsList) elif outputName == "probabilities": return len(self.stepsList) * self.maxCategoryCount elif outputName == "actualValues": return self.maxCategoryCount else: raise ValueError("Unknown output {}.".format(outputName)) if __name__ == "__main__": from nupic.engine import Network n = Network() classifier = n.addRegion( 'classifier', 'py.CLAClassifierRegion', '{ steps: "1,2", maxAge: 1000}' )
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 createMultiLevelNetwork(dataSource): network = Network() # Create and add a record sensor and a SP region sensor = NetworkUtils.createRecordSensor(network, name=_RECORD_SENSOR, dataSource=dataSource, multilevelAnomaly=True) NetworkUtils.createSpatialPooler(network, name=_L1_SPATIAL_POOLER, inputWidth=sensor.encoder.getWidth()) # Link the SP region to the sensor input linkType = "UniformLink" linkParams = "" network.link(_RECORD_SENSOR, _L1_SPATIAL_POOLER, linkType, linkParams) # Create and add a TM region l1temporalMemory = NetworkUtils.createTemporalMemory(network, _L1_TEMPORAL_MEMORY) # Link SP region to TM region in the feedforward direction network.link(_L1_SPATIAL_POOLER, _L1_TEMPORAL_MEMORY, linkType, linkParams) # Add a classifier classifierParams = { # Learning rate. Higher values make it adapt faster. 'alpha': 0.005, # A comma separated list of the number of steps the # classifier predicts in the future. The classifier will # learn predictions of each order specified. 'steps': '1,2,3,4,5,6,7', # The specific implementation of the classifier to use # See SDRClassifierFactory#create for options 'implementation': 'py', # Diagnostic output verbosity control; # 0: silent; [1..6]: increasing levels of verbosity 'verbosity': 0} l1Classifier = network.addRegion(_L1_CLASSIFIER, "py.SDRClassifierRegion", json.dumps(classifierParams)) l1Classifier.setParameter('inferenceMode', True) l1Classifier.setParameter('learningMode', True) network.link(_L1_TEMPORAL_MEMORY, _L1_CLASSIFIER, linkType, linkParams, srcOutput="bottomUpOut", destInput="bottomUpIn") network.link(_RECORD_SENSOR, _L1_CLASSIFIER, linkType, linkParams, srcOutput="categoryOut", destInput="categoryIn") network.link(_RECORD_SENSOR, _L1_CLASSIFIER, linkType, linkParams, srcOutput="bucketIdxOut", destInput="bucketIdxIn") network.link(_RECORD_SENSOR, _L1_CLASSIFIER, linkType, linkParams, srcOutput="actValueOut", destInput="actValueIn") # Second Level l2inputWidth = l1temporalMemory.getSelf().getOutputElementCount("bottomUpOut") NetworkUtils.createSpatialPooler(network, name=_L2_SPATIAL_POOLER, inputWidth=l2inputWidth) network.link(_L1_TEMPORAL_MEMORY, _L2_SPATIAL_POOLER, linkType, linkParams) NetworkUtils.createTemporalMemory(network, _L2_TEMPORAL_MEMORY) network.link(_L2_SPATIAL_POOLER, _L2_TEMPORAL_MEMORY, linkType, linkParams) l2Classifier = network.addRegion(_L2_CLASSIFIER, "py.SDRClassifierRegion", json.dumps(classifierParams)) l2Classifier.setParameter('inferenceMode', True) l2Classifier.setParameter('learningMode', True) network.link(_L2_TEMPORAL_MEMORY, _L2_CLASSIFIER, linkType, linkParams, srcOutput="bottomUpOut", destInput="bottomUpIn") network.link(_RECORD_SENSOR, _L2_CLASSIFIER, linkType, linkParams, srcOutput="categoryOut", destInput="categoryIn") network.link(_RECORD_SENSOR, _L2_CLASSIFIER, linkType, linkParams, srcOutput="bucketIdxOut", destInput="bucketIdxIn") network.link(_RECORD_SENSOR, _L2_CLASSIFIER, linkType, linkParams, srcOutput="actValueOut", destInput="actValueIn") steps = l2Classifier.getSelf().stepsList # initialize the results matrix, after the classifer has been defined w, h = len(steps), len(steps)+1 global results results = [[-1 for x in range(w)] for y in range(h)] global l1ErrorSum l2ErrorSum = [-1 for x in range(h)] #print("Length: "+str(len(steps))) return network
def _createNetwork(inverseReadoutResolution, anchorInputSize, dualPhase=False): """ Create a simple network connecting sensor and motor inputs to the location region. Use :meth:`RawSensor.addDataToQueue` to add sensor input and growth candidates. Use :meth:`RawValues.addDataToQueue` to add motor input. :: +----------+ [ sensor* ] --> | | --> [ activeCells ] [ candidates* ] --> | location | --> [ learnableCells ] [ motor ] --> | | --> [ sensoryAssociatedCells ] +----------+ :param inverseReadoutResolution: Specifies the diameter of the circle of phases in the rhombus encoded by a bump. :type inverseReadoutResolution: int :type anchorInputSize: int :param anchorInputSize: The number of input bits in the anchor input. .. note:: (*) This function will only add the 'sensor' and 'candidates' regions when 'anchorInputSize' is greater than zero. This is useful if you would like to compute locations ignoring sensor input .. seealso:: - :py:func:`htmresearch.frameworks.location.path_integration_union_narrowing.createRatModuleFromReadoutResolution` """ net = Network() # Create simple region to pass motor commands as displacement vectors (dx, dy) net.addRegion("motor", "py.RawValues", json.dumps({"outputWidth": 2})) if anchorInputSize > 0: # Create simple region to pass growth candidates net.addRegion("candidates", "py.RawSensor", json.dumps({"outputWidth": anchorInputSize})) # Create simple region to pass sensor input net.addRegion("sensor", "py.RawSensor", json.dumps({"outputWidth": anchorInputSize})) # Initialize region with 5 modules varying scale by sqrt(2) and 4 different # random orientations for each scale scale = [] orientation = [] for i in xrange(5): for _ in xrange(4): angle = np.radians(random.gauss(7.5, 7.5)) orientation.append(random.choice([angle, -angle])) scale.append(10.0 * (math.sqrt(2)**i)) # Create location region params = computeRatModuleParametersFromReadoutResolution( inverseReadoutResolution) params.update({ "moduleCount": len(scale), "scale": scale, "orientation": orientation, "anchorInputSize": anchorInputSize, "activationThreshold": 8, "initialPermanence": 1.0, "connectedPermanence": 0.5, "learningThreshold": 8, "sampleSize": 10, "permanenceIncrement": 0.1, "permanenceDecrement": 0.0, "dualPhase": dualPhase, "bumpOverlapMethod": "probabilistic" }) net.addRegion("location", "py.GridCellLocationRegion", json.dumps(params)) if anchorInputSize > 0: # Link sensor net.link("sensor", "location", "UniformLink", "", srcOutput="dataOut", destInput="anchorInput") net.link("sensor", "location", "UniformLink", "", srcOutput="resetOut", destInput="resetIn") net.link("candidates", "location", "UniformLink", "", srcOutput="dataOut", destInput="anchorGrowthCandidates") # Link motor input net.link("motor", "location", "UniformLink", "", srcOutput="dataOut", destInput="displacement") # Initialize network objects net.initialize() return net
def _createOPFNetwork(addSP=True, addTP=False): """Create a 'new-style' network ala OPF and return it. If addSP is true, an SPRegion will be added named 'level1SP'. If addTP is true, a TPRegion will be added named 'level1TP' """ # ========================================================================== # Create the encoder and data source stuff we need to configure the sensor sensorParams = dict(verbosity=_VERBOSITY) encoder = _createEncoder() trainFile = resource_filename("nupic.datafiles", "extra/gym/gym.csv") dataSource = FileRecordStream(streamID=trainFile) dataSource.setAutoRewind(True) # ========================================================================== # Now create the network itself n = Network() n.addRegion("sensor", "py.RecordSensor", json.dumps(sensorParams)) sensor = n.regions['sensor'].getSelf() sensor.encoder = encoder sensor.dataSource = dataSource # ========================================================================== # Add the SP if requested if addSP: print "Adding SPRegion" g_spRegionConfig['inputWidth'] = encoder.getWidth() n.addRegion("level1SP", "py.SPRegion", json.dumps(g_spRegionConfig)) n.link("sensor", "level1SP", "UniformLink", "") n.link("sensor", "level1SP", "UniformLink", "", srcOutput="resetOut", destInput="resetIn") n.link("level1SP", "sensor", "UniformLink", "", srcOutput="spatialTopDownOut", destInput="spatialTopDownIn") n.link("level1SP", "sensor", "UniformLink", "", srcOutput="temporalTopDownOut", destInput="temporalTopDownIn") # ========================================================================== if addTP and addSP: # Add the TP on top of SP if requested # The input width of the TP is set to the column count of the SP print "Adding TPRegion on top of SP" g_tpRegionConfig['inputWidth'] = g_spRegionConfig['columnCount'] n.addRegion("level1TP", "py.TPRegion", json.dumps(g_tpRegionConfig)) n.link("level1SP", "level1TP", "UniformLink", "") n.link("level1TP", "level1SP", "UniformLink", "", srcOutput="topDownOut", destInput="topDownIn") n.link("sensor", "level1TP", "UniformLink", "", srcOutput="resetOut", destInput="resetIn") elif addTP: # Add a lone TPRegion if requested # The input width of the TP is set to the encoder width print "Adding TPRegion" g_tpRegionConfig['inputWidth'] = encoder.getWidth() n.addRegion("level1TP", "py.TPRegion", json.dumps(g_tpRegionConfig)) n.link("sensor", "level1TP", "UniformLink", "") n.link("sensor", "level1TP", "UniformLink", "", srcOutput="resetOut", destInput="resetIn") return n
def runNodesTest(self, nodeType1, nodeType2): # ===================================================== # Build and run the network # ===================================================== LOGGER.info('test(level1: %s, level2: %s)', nodeType1, nodeType2) net = Network() level1 = net.addRegion("level1", nodeType1, "{int32Param: 15}") dims = Dimensions([6, 4]) level1.setDimensions(dims) level2 = net.addRegion("level2", nodeType2, "{real64Param: 128.23}") net.link("level1", "level2", "TestFanIn2", "") # Could call initialize here, but not necessary as net.run() # initializes implicitly. # net.initialize() net.run(1) LOGGER.info("Successfully created network and ran for one iteration") # ===================================================== # Check everything # ===================================================== dims = level1.getDimensions() self.assertEqual(len(dims), 2) self.assertEqual(dims[0], 6) self.assertEqual(dims[1], 4) dims = level2.getDimensions() self.assertEqual(len(dims), 2) self.assertEqual(dims[0], 3) self.assertEqual(dims[1], 2) # Check L1 output. "False" means don't copy, i.e. # get a pointer to the actual output # Actual output values are determined by the TestNode # compute() behavior. l1output = level1.getOutputData("bottomUpOut") self.assertEqual(len(l1output), 48) # 24 nodes; 2 values per node for i in xrange(24): self.assertEqual(l1output[2 * i], 0) # size of input to each node is 0 self.assertEqual(l1output[2 * i + 1], i) # node number # check L2 output. l2output = level2.getOutputData("bottomUpOut") self.assertEqual(len(l2output), 12) # 6 nodes; 2 values per node # Output val = node number + sum(inputs) # Can compute from knowing L1 layout # # 00 01 | 02 03 | 04 05 # 06 07 | 08 09 | 10 11 # --------------------- # 12 13 | 14 15 | 16 17 # 18 19 | 20 21 | 22 23 outputVals = [] outputVals.append(0 + (0 + 1 + 6 + 7)) outputVals.append(1 + (2 + 3 + 8 + 9)) outputVals.append(2 + (4 + 5 + 10 + 11)) outputVals.append(3 + (12 + 13 + 18 + 19)) outputVals.append(4 + (14 + 15 + 20 + 21)) outputVals.append(5 + (16 + 17 + 22 + 23)) for i in xrange(6): if l2output[2 * i] != 8: LOGGER.info(l2output[2 * i]) # from dbgp.client import brk; brk(port=9019) self.assertEqual(l2output[2 * i], 8) # size of input for each node is 8 self.assertEqual(l2output[2 * i + 1], outputVals[i]) # ===================================================== # Run for one more iteration # ===================================================== LOGGER.info("Running for a second iteration") net.run(1) # ===================================================== # Check everything again # ===================================================== # Outputs are all the same except that the first output is # incremented by the iteration number for i in xrange(24): self.assertEqual(l1output[2 * i], 1) self.assertEqual(l1output[2 * i + 1], i) for i in xrange(6): self.assertEqual(l2output[2 * i], 9) self.assertEqual(l2output[2 * i + 1], outputVals[i] + 4) # ===================================================== # Demonstrate a few other features # ===================================================== # # Linking can induce dimensions downward # net = Network() level1 = net.addRegion("level1", nodeType1, "") level2 = net.addRegion("level2", nodeType2, "") dims = Dimensions([3, 2]) level2.setDimensions(dims) net.link("level1", "level2", "TestFanIn2", "") net.initialize() # Level1 should now have dimensions [6, 4] self.assertEqual(level1.getDimensions()[0], 6) self.assertEqual(level1.getDimensions()[1], 4)
def createNetwork(dataSource): """Creates and returns a new Network with a sensor region reading data from 'dataSource'. There are two hierarchical levels, each with one SP and one TP. @param dataSource - A RecordStream containing the input data @returns a Network ready to run """ network = Network() # Create and add a record sensor and a SP region sensor = createRecordSensor(network, name=_RECORD_SENSOR, dataSource=dataSource) createSpatialPooler(network, name=_L1_SPATIAL_POOLER, inputWidth=sensor.encoder.getWidth()) # Link the SP region to the sensor input linkType = "UniformLink" linkParams = "" network.link(_RECORD_SENSOR, _L1_SPATIAL_POOLER, linkType, linkParams) # Create and add a TP region l1temporalMemory = createTemporalMemory(network, _L1_TEMPORAL_MEMORY) # Link SP region to TP region in the feedforward direction network.link(_L1_SPATIAL_POOLER, _L1_TEMPORAL_MEMORY, linkType, linkParams) # Add a classifier classifierParams = { # Learning rate. Higher values make it adapt faster. 'alpha': 0.005, # A comma separated list of the number of steps the # classifier predicts in the future. The classifier will # learn predictions of each order specified. 'steps': '1', # The specific implementation of the classifier to use # See SDRClassifierFactory#create for options 'implementation': 'py', # Diagnostic output verbosity control; # 0: silent; [1..6]: increasing levels of verbosity 'verbosity': 0 } l1Classifier = network.addRegion(_L1_CLASSIFIER, "py.SDRClassifierRegion", json.dumps(classifierParams)) l1Classifier.setParameter('inferenceMode', True) l1Classifier.setParameter('learningMode', True) network.link(_L1_TEMPORAL_MEMORY, _L1_CLASSIFIER, linkType, linkParams, srcOutput="bottomUpOut", destInput="bottomUpIn") # Second Level l2inputWidth = l1temporalMemory.getSelf().getOutputElementCount( "bottomUpOut") createSpatialPooler(network, name=_L2_SPATIAL_POOLER, inputWidth=l2inputWidth) network.link(_L1_TEMPORAL_MEMORY, _L2_SPATIAL_POOLER, linkType, linkParams) createTemporalMemory(network, _L2_TEMPORAL_MEMORY) network.link(_L2_SPATIAL_POOLER, _L2_TEMPORAL_MEMORY, linkType, linkParams) l2Classifier = network.addRegion(_L2_CLASSIFIER, "py.SDRClassifierRegion", json.dumps(classifierParams)) l2Classifier.setParameter('inferenceMode', True) l2Classifier.setParameter('learningMode', True) network.link(_L2_TEMPORAL_MEMORY, _L2_CLASSIFIER, linkType, linkParams, srcOutput="bottomUpOut", destInput="bottomUpIn") return network
def createNetwork(dataSource): """Create the Network instance. The network has a sensor region reading data from `dataSource` and passing the encoded representation to an SPRegion. The SPRegion output is passed to a TPRegion. :param dataSource: a RecordStream instance to get data from :returns: a Network instance ready to run """ network = Network() # Our input is sensor data from the gym file. The RecordSensor region # allows us to specify a file record stream as the input source via the # dataSource attribute. network.addRegion("sensor", "py.RecordSensor", json.dumps({"verbosity": _VERBOSITY})) sensor = network.regions["sensor"].getSelf() # The RecordSensor needs to know how to encode the input values sensor.encoder = createEncoder() # Specify the dataSource as a file record stream instance sensor.dataSource = dataSource # Create the spatial pooler region SP_PARAMS["inputWidth"] = sensor.encoder.getWidth() network.addRegion("spatialPoolerRegion", "py.SPRegion", json.dumps(SP_PARAMS)) # 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(TP_PARAMS)) network.link("spatialPoolerRegion", "temporalPoolerRegion", "UniformLink", "") network.link("temporalPoolerRegion", "spatialPoolerRegion", "UniformLink", "", srcOutput="topDownOut", destInput="topDownIn") network.initialize() 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. This actually doesn't work # now so doesn't matter. We instead compute the anomaly score based on # topDownOut (predicted columns) and SP bottomUpOut (active columns). temporalPoolerRegion.setParameter("anomalyMode", True) return network
def testSerialization(self): n = Network() imageDims = (42, 38) params = dict(width=imageDims[0], height=imageDims[1], mode="bw", background=1, invertOutput=1) sensor = n.addRegion("sensor", "py.ImageSensor", json.dumps(params)) sensor.setDimensions(Dimensions(imageDims[0], imageDims[1])) params = dict(inputShape=imageDims, coincidencesShape=imageDims, disableTemporal=1, tpSeed=43, spSeed=42, nCellsPerCol=1) l1 = n.addRegion("l1", "py.CLARegion", json.dumps(params)) params = dict(maxCategoryCount=48, SVDSampleCount=400, SVDDimCount=5, distanceNorm=0.6) _classifier = n.addRegion("classifier", "py.KNNClassifierRegion", json.dumps(params)) # TODO: link params should not be required. Dest region dimensions are # already specified as [1] params = dict(mapping="in", rfSize=imageDims) n.link("sensor", "l1", "UniformLink", json.dumps(params)) n.link("l1", "classifier", "UniformLink", "", "bottomUpOut", "bottomUpIn") n.link("sensor", "classifier", "UniformLink", "", "categoryOut", "categoryIn") n.initialize() n.save("fdr.nta") # Make sure the network bundle has all the expected files self.assertTrue(os.path.exists("fdr.nta/network.yaml")) self.assertTrue(os.path.exists("fdr.nta/R0-pkl")) self.assertTrue(os.path.exists("fdr.nta/R1-pkl")) self.assertTrue(os.path.exists("fdr.nta/R2-pkl")) n2 = Network("fdr.nta") n2.initialize() # should not fail # Make sure the network is actually the same sensor = n2.regions['sensor'] self.assertEqual(sensor.type, "py.ImageSensor") # would like to directly compare, but can't -- NPC-6 self.assertEqual(str(sensor.dimensions), str(Dimensions(42, 38))) self.assertEqual(sensor.getParameter("width"), 42) self.assertEqual(sensor.getParameter("height"), 38) self.assertEqual(sensor.getParameter("mode"), "bw") self.assertEqual(sensor.getParameter("background"), 1) self.assertEqual(sensor.getParameter("invertOutput"), 1) l1 = n2.regions['l1'] self.assertEqual(l1.type, "py.CLARegion") self.assertEqual(str(l1.dimensions), str(Dimensions(1))) a = l1.getParameter("inputShape") self.assertEqual(len(a), 2) self.assertEqual(a[0], 42) self.assertEqual(a[1], 38) a = l1.getParameter("coincidencesShape") self.assertEqual(len(a), 2) self.assertEqual(a[0], 42) self.assertEqual(a[1], 38) self.assertEqual(l1.getParameter("disableTemporal"), 1) self.assertEqual(l1.getParameter("spSeed"), 42) self.assertEqual(l1.getParameter("tpSeed"), 43) cl = n2.regions['classifier'] self.assertEqual(cl.type, "py.KNNClassifierRegion") self.assertEqual(cl.getParameter("maxCategoryCount"), 48) self.assertEqual(cl.getParameter("SVDSampleCount"), 400) self.assertEqual(cl.getParameter("SVDDimCount"), 5) self.assertLess((cl.getParameter("distanceNorm") - 0.6), 0.0001) self.assertEqual(str(cl.dimensions), str(Dimensions(1))) n2.save("fdr2.nta") # now compare the two network bundles -- should be the same c = filecmp.dircmp("fdr.nta", "fdr2.nta") self.assertEqual(len(c.left_only), 0, "fdr.nta has extra files: %s" % c.left_only) self.assertEqual(len(c.right_only), 0, "fdr2.nta has extra files: %s" % c.right_only) if len(c.diff_files) > 0: _LOGGER.warn( "Some bundle files differ: %s\n" "This is expected, as pickle.load() followed by " "pickle.dump() doesn't produce the same file", c.diff_files)