def runExperiment():
Network.unregisterRegion("ImageSensor")
Network.registerRegion(ImageSensor)
Network.registerRegion(PCANode)
inputSize = 8
net = Network()
sensor = net.addRegion(
"sensor", "py.ImageSensor",
"{ width: %d, height: %d }" % (inputSize, inputSize))
params = ("{bottomUpCount: %s, "
" SVDSampleCount: 5, "
" SVDDimCount: 2}" % inputSize)
pca = net.addRegion("pca", "py.PCANode", params)
linkParams = "{ mapping: in, rfSize: [%d, %d] }" % (inputSize, inputSize)
net.link("sensor", "pca", "UniformLink", linkParams, "dataOut",
"bottomUpIn")
net.initialize()
for i in range(10):
pca.getSelf()._testInputs = numpy.random.random([inputSize])
net.run(1)
print s.sendRequest("nodeOPrint pca_node")
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 testRunPCANode(self):
from nupic.engine import *
numpy.random.RandomState(37)
inputSize = 8
net = Network()
Network.registerRegion(ImageSensor)
net.addRegion('sensor', 'py.ImageSensor' ,
'{ width: %d, height: %d }' % (inputSize, inputSize))
params = """{bottomUpCount: %d,
SVDSampleCount: 5,
SVDDimCount: 2}""" % inputSize
pca = net.addRegion('pca', 'py.PCANode', params)
#nodeAbove = CreateNode("py.ImageSensor", phase=0, categoryOut=1, dataOut=3,
# width=3, height=1)
#net.addElement('nodeAbove', nodeAbove)
linkParams = '{ mapping: in, rfSize: [%d, %d] }' % (inputSize, inputSize)
net.link('sensor', 'pca', 'UniformLink', linkParams, 'dataOut', 'bottomUpIn')
net.initialize()
for i in range(10):
pca.getSelf()._testInputs = numpy.random.random([inputSize])
net.run(1)
def runExperiment():
Network.unregisterRegion("ImageSensor")
Network.registerRegion(ImageSensor)
Network.registerRegion(PCANode)
inputSize = 8
net = Network()
sensor = net.addRegion(
"sensor", "py.ImageSensor" ,
"{ width: %d, height: %d }" % (inputSize, inputSize))
params = ("{bottomUpCount: %s, "
" SVDSampleCount: 5, "
" SVDDimCount: 2}" % inputSize)
pca = net.addRegion("pca", "py.PCANode", params)
linkParams = "{ mapping: in, rfSize: [%d, %d] }" % (inputSize, inputSize)
net.link("sensor", "pca", "UniformLink", linkParams, "dataOut", "bottomUpIn")
net.initialize()
for i in range(10):
pca.getSelf()._testInputs = numpy.random.random([inputSize])
net.run(1)
print s.sendRequest("nodeOPrint pca_node")
def __init__(self, numColumns, L2Params, L4Params, L6aParams, repeat,
logCalls=False):
"""
Create a network consisting of multiple columns. Each column contains one L2,
one L4 and one L6a layers. In addition all the L2 columns are fully
connected to each other through their lateral inputs.
:param numColumns: Number of columns to create
:type numColumns: int
:param L2Params: constructor parameters for :class:`ColumnPoolerRegion`
:type L2Params: dict
:param L4Params: constructor parameters for :class:`ApicalTMPairRegion`
:type L4Params: dict
:param L6aParams: constructor parameters for :class:`GridCellLocationRegion`
:type L6aParams: dict
:param repeat: Number of times each pair should be seen to be learned
:type repeat: int
:param logCalls: If true, calls to main functions will be logged internally.
The log can then be saved with saveLogs(). This allows us
to recreate the complete network behavior using
rerunExperimentFromLogfile which is very useful for
debugging.
:type logCalls: bool
"""
# Handle logging - this has to be done first
self.logCalls = logCalls
self.numColumns = numColumns
self.repeat = repeat
network = Network()
self.network = createMultipleL246aLocationColumn(network=network,
numberOfColumns=self.numColumns,
L2Params=L2Params,
L4Params=L4Params,
L6aParams=L6aParams)
network.initialize()
self.sensorInput = []
self.motorInput = []
self.L2Regions = []
self.L4Regions = []
self.L6aRegions = []
for i in xrange(self.numColumns):
col = str(i)
self.sensorInput.append(network.regions["sensorInput_" + col].getSelf())
self.motorInput.append(network.regions["motorInput_" + col].getSelf())
self.L2Regions.append(network.regions["L2_" + col])
self.L4Regions.append(network.regions["L4_" + col])
self.L6aRegions.append(network.regions["L6a_" + col])
if L6aParams is not None and "dimensions" in L6aParams:
self.dimensions = L6aParams["dimensions"]
else:
self.dimensions = 2
self.sdrSize = L2Params["sdrSize"]
# will be populated during training
self.learnedObjects = {}
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)
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 testRunPCANode(self):
from nupic.engine import *
numpy.random.RandomState(37)
inputSize = 8
net = Network()
Network.registerRegion(ImageSensor)
net.addRegion('sensor', 'py.ImageSensor',
'{ width: %d, height: %d }' % (inputSize, inputSize))
params = """{bottomUpCount: %d,
SVDSampleCount: 5,
SVDDimCount: 2}""" % inputSize
pca = net.addRegion('pca', 'py.PCANode', params)
#nodeAbove = CreateNode("py.ImageSensor", phase=0, categoryOut=1, dataOut=3,
# width=3, height=1)
#net.addElement('nodeAbove', nodeAbove)
linkParams = '{ mapping: in, rfSize: [%d, %d] }' % (inputSize,
inputSize)
net.link('sensor', 'pca', 'UniformLink', linkParams, 'dataOut',
'bottomUpIn')
net.initialize()
for i in range(10):
pca.getSelf()._testInputs = numpy.random.random([inputSize])
net.run(1)
def createNetwork(dataSource, rdse_resolution, cellsPerMiniColumn=32):
"""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 TMRegion.
:param dataSource: a RecordStream instance to get data from
:param cellsPerMiniColumn: int, number of cells per mini-column. Default=32
:returns: a Network instance ready to run
"""
try:
with open(_PARAMS_PATH, "r") as f:
modelParams = yaml.safe_load(f)["modelParams"]
except:
with open(os.path.join("..", _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.encoder = createEncoder(rdse_resolution)
sensorRegion.dataSource = dataSource
# Make sure the SP input width matches the sensor region output width.
modelParams["spParams"]["inputWidth"] = sensorRegion.encoder.getWidth()
modelParams["tmParams"]["cellsPerColumn"] = cellsPerMiniColumn
# Add SP and TM regions.
network.addRegion("spatialPoolerRegion", "py.SPRegion",
json.dumps(modelParams["spParams"]))
network.addRegion("temporalPoolerRegion", "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"]))
# Add all links
createSensorToClassifierLinks(network, "sensor", "classifier")
createDataOutLink(network, "sensor", "spatialPoolerRegion")
createFeedForwardLink(network, "spatialPoolerRegion",
"temporalPoolerRegion")
createFeedForwardLink(network, "temporalPoolerRegion", "classifier")
# Reset links are optional, since the sensor region does not send resets.
createResetLink(network, "sensor", "spatialPoolerRegion")
createResetLink(network, "sensor", "temporalPoolerRegion")
# Make sure all objects are initialized.
network.initialize()
return network
def createNetwork():
"""Create the Network instance.
The network has a sensor region reading data from `rataSource` 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()
# Create Sensor
network.addRegion("sensor", "py.RecordSensor", json.dumps({"verbosity":
0}))
sensor = network.regions["sensor"].getSelf()
sensor.encoder = createSensorEncoder()
sensor.dataSource = DataBuffer()
# Add the spatial pooler region
PARAMS['SP']["inputWidth"] = sensor.encoder.getWidth()
network.addRegion("spatialPoolerRegion", "py.SPRegion",
json.dumps(PARAMS['SP']))
network.link("sensor", "spatialPoolerRegion", "UniformLink", "")
# Add the TPRegion on top of the SPRegion
network.addRegion("temporalPoolerRegion", "py.TPRegion",
json.dumps(PARAMS['TP']))
network.link("spatialPoolerRegion", "temporalPoolerRegion", "UniformLink",
"")
# Add classifier
network.addRegion("classifierRegion", "py.CLAClassifierRegion",
json.dumps(PARAMS['CL']))
network.initialize()
# Make sure learning is enabled
spatialPoolerRegion = network.regions["spatialPoolerRegion"]
spatialPoolerRegion.setParameter("learningMode", True)
spatialPoolerRegion.setParameter("anomalyMode", True)
temporalPoolerRegion = network.regions["temporalPoolerRegion"]
temporalPoolerRegion.setParameter("topDownMode", False)
temporalPoolerRegion.setParameter("learningMode", True)
temporalPoolerRegion.setParameter("inferenceMode", True)
temporalPoolerRegion.setParameter("anomalyMode", False)
classifierRegion = network.regions["classifierRegion"]
classifierRegion.setParameter('inferenceMode', True)
classifierRegion.setParameter('learningMode', True)
return network
def createNetwork():
"""Create the Network instance.
The network has a sensor region reading data from `rataSource` 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()
# Create Sensor
network.addRegion("sensor", "py.RecordSensor", json.dumps({"verbosity": 0}))
sensor = network.regions["sensor"].getSelf()
sensor.encoder = createSensorEncoder()
sensor.dataSource = DataBuffer()
# Add the spatial pooler region
PARAMS['SP']["inputWidth"] = sensor.encoder.getWidth()
network.addRegion("spatialPoolerRegion", "py.SPRegion", json.dumps(PARAMS['SP']))
network.link("sensor", "spatialPoolerRegion", "UniformLink", "")
# Add the TPRegion on top of the SPRegion
network.addRegion("temporalPoolerRegion", "py.TPRegion", json.dumps(PARAMS['TP']))
network.link("spatialPoolerRegion", "temporalPoolerRegion", "UniformLink", "")
# Add classifier
network.addRegion( "classifierRegion", "py.CLAClassifierRegion", json.dumps(PARAMS['CL']))
network.initialize()
# Make sure learning is enabled
spatialPoolerRegion = network.regions["spatialPoolerRegion"]
spatialPoolerRegion.setParameter("learningMode", True)
spatialPoolerRegion.setParameter("anomalyMode", True)
temporalPoolerRegion = network.regions["temporalPoolerRegion"]
temporalPoolerRegion.setParameter("topDownMode", False)
temporalPoolerRegion.setParameter("learningMode", True)
temporalPoolerRegion.setParameter("inferenceMode", True)
temporalPoolerRegion.setParameter("anomalyMode", False)
classifierRegion = network.regions["classifierRegion"]
classifierRegion.setParameter('inferenceMode', True)
classifierRegion.setParameter('learningMode', True)
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(I_PARAMS))
# Link the Identity region to the sensor input
network.link("sensor",
"identityRegion",
"UniformLink",
"",
srcOutput="sourceOut",
destInput="in")
network.initialize()
return network
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 _testNetLoad(self):
"""Test loading a network with this sensor in it."""
n = Network()
r = n.addRegion(self.nodeName, self.sensorName, '{ activeOutputCount: 11}')
r.dimensions = Dimensions([1])
n.save(self.filename)
n = Network(self.filename)
n.initialize()
self.testsPassed += 1
# Check that vectorCount parameter is zero
r = n.regions[self.nodeName]
res = r.getParameter('vectorCount')
self.assertEqual(
res, 0, "getting vectorCount:\n Expected '0', got back '%d'\n" % res)
self.sensor = r
def _testNetLoad(self):
"""Test loading a network with this sensor in it."""
n = Network()
r = n.addRegion(self.nodeName, self.sensorName, '{ activeOutputCount: 11}')
r.dimensions = Dimensions([1])
n.save(self.filename)
n = Network(self.filename)
n.initialize()
self.testsPassed += 1
# Check that vectorCount parameter is zero
r = n.regions[self.nodeName]
res = r.getParameter('vectorCount')
self.assertEqual(
res, 0, "getting vectorCount:\n Expected '0', got back '%d'\n" % res)
self.sensor = r
def testLinkingDownwardDimensions(self):
#
# Linking can induce dimensions downward
#
net = Network()
level1 = net.addRegion("level1", "TestNode", "")
level2 = net.addRegion("level2", "TestNode", "")
dims = Dimensions([3, 2])
level2.setDimensions(dims)
net.link("level1", "level2", "TestFanIn2", "")
net.initialize()
# Level1 should now have dimensions [6, 4]
self.assertEquals(level1.getDimensions()[0], 6)
self.assertEquals(level1.getDimensions()[1], 4)
#
# We get nice error messages when network can't be initialized
#
LOGGER.info("=====")
LOGGER.info("Creating a 3 level network in which levels 1 and 2 have")
LOGGER.info("dimensions but network initialization will fail because")
LOGGER.info("level3 does not have dimensions")
LOGGER.info("Error message follows:")
net = Network()
level1 = net.addRegion("level1", "TestNode", "")
level2 = net.addRegion("level2", "TestNode", "")
_level3 = net.addRegion("level3", "TestNode", "")
dims = Dimensions([6, 4])
level1.setDimensions(dims)
net.link("level1", "level2", "TestFanIn2", "")
self.assertRaises(RuntimeError, net.initialize)
LOGGER.info("=====")
LOGGER.info("======")
LOGGER.info("Creating a link with incompatible dimensions. \
Error message follows")
net.link("level2", "level3", "TestFanIn2", "")
self.assertRaises(RuntimeError, net.initialize)
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 TM 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"]))
# 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 testLinkingDownwardDimensions(self):
#
# Linking can induce dimensions downward
#
net = Network()
level1 = net.addRegion("level1", "TestNode", "")
level2 = net.addRegion("level2", "TestNode", "")
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)
#
# We get nice error messages when network can't be initialized
#
LOGGER.info("=====")
LOGGER.info("Creating a 3 level network in which levels 1 and 2 have")
LOGGER.info("dimensions but network initialization will fail because")
LOGGER.info("level3 does not have dimensions")
LOGGER.info("Error message follows:")
net = Network()
level1 = net.addRegion("level1", "TestNode", "")
level2 = net.addRegion("level2", "TestNode", "")
_level3 = net.addRegion("level3", "TestNode", "")
dims = Dimensions([6, 4])
level1.setDimensions(dims)
net.link("level1", "level2", "TestFanIn2", "")
self.assertRaises(RuntimeError, net.initialize)
LOGGER.info("=====")
LOGGER.info("======")
LOGGER.info("Creating a link with incompatible dimensions. \
Error message follows")
net.link("level2", "level3", "TestFanIn2", "")
self.assertRaises(RuntimeError, net.initialize)
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 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 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 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
# TODO: Needs TMRegion
network.addRegion("temporalMemoryRegion", "py.TPRegion",
json.dumps(TP_PARAMS))
network.link("spatialPoolerRegion", "temporalMemoryRegion", "UniformLink", "")
network.link("temporalMemoryRegion", "spatialPoolerRegion", "UniformLink", "",
srcOutput="topDownOut", destInput="topDownIn")
# Register UPRegion since we aren't in nupic
curDirectory = os.path.dirname(os.path.abspath(__file__))
# directory containing the union pooler directory is 2 directories above this file
unionPoolerDirectory = os.path.split((os.path.split(curDirectory))[0])[0]
sys.path.append(unionPoolerDirectory)
Network.registerRegionPackage("union_pooling")
# Add the UPRegion on top of the TPRegion
temporal = network.regions["temporalMemoryRegion"].getSelf()
UP_PARAMS["inputWidth"] = temporal.getOutputElementCount("bottomUpOut")
network.addRegion("unionPoolerRegion", "py.PoolingRegion", json.dumps(UP_PARAMS))
network.link("temporalMemoryRegion", "unionPoolerRegion", "UniformLink", "",
srcOutput="activeCells", destInput="activeCells")
network.link("temporalMemoryRegion", "unionPoolerRegion", "UniformLink", "",
srcOutput="predictedActiveCells", destInput="predictedActiveCells")
network.initialize()
spatial = network.regions["spatialPoolerRegion"].getSelf()
# Make sure learning is enabled (this is the default)
spatial.setParameter("learningMode", 1, True)
# We want temporal anomalies so disable anomalyMode in the SP. This mode is
# used for computing anomalies in a non-temporal model.
spatial.setParameter("anomalyMode", 1, False)
# Enable topDownMode to get the predicted columns output
temporal.setParameter("topDownMode", 1, True)
# Make sure learning is enabled (this is the default)
temporal.setParameter("learningMode", 1, True)
# Enable inference mode so we get predictions
temporal.setParameter("inferenceMode", 1, True)
temporal.setParameter("computePredictedActiveCellIndices", 1, True)
union = network.regions["unionPoolerRegion"].getSelf()
# Make sure learning is enabled (this is the default)
union.setParameter("learningMode", 1, True)
return network
class FunctionRecogniter():
def __init__(self):
self.run_number = 0
# for classifier
self.classifier_encoder_list = {}
self.classifier_input_list = {}
self.prevPredictedColumns = {}
self.selectivity = "region2"
# net structure
self.net_structure = OrderedDict()
self.net_structure['sensor3'] = ['region1']
self.net_structure['region1'] = ['region2']
# self.net_structure['sensor1'] = ['region1']
# self.net_structure['sensor2'] = ['region2']
# self.net_structure['region1'] = ['region3']
# self.net_structure['region2'] = ['region3']
# region change params
self.dest_resgion_data = {
'region1': {
'TP_PARAMS':{
"cellsPerColumn": 8,
"permanenceInc": 0.2,
"permanenceDec": 0.1,
#"permanenceDec": 0.0001,
},
},
'region2': {
'SP_PARAMS':{
"inputWidth": 2024 * (8),
},
'TP_PARAMS':{
"cellsPerColumn": 8,
"permanenceInc": 0.2,
"permanenceDec": 0.1,
},
},
# 'region3': {
# 'SP_PARAMS':{
# "inputWidth": 2024 * (8),
# },
# 'TP_PARAMS':{
# "cellsPerColumn": 8,
# },
# },
}
# sensor change params
self.sensor_params = {
'sensor1': {
'xy_value': None,
'x_value': {
"fieldname": u"x_value",
"name": u"x_value",
"type": "ScalarEncoder",
'maxval': 100.0,
'minval': 0.0,
"n": 200,
"w": 21,
"clipInput": True
},
},
'sensor2': {
'xy_value': None,
'y_value': {
"fieldname": u"y_value",
"name": u"y_value",
"type": "ScalarEncoder",
'maxval': 100.0,
'minval': 0.0,
"n": 200,
"w": 21,
"clipInput": True
},
},
'sensor3': {
'xy_value': {
'maxval': 100.0,
'minval': 0.0
},
},
# 'sensor3': {
# 'xy_value': {
# 'maxval': 100.0,
# 'minval': 40.0
# },
# },
}
self._createNetwork()
# for evaluate netwrok accuracy
self.evaluation = {}
for name in self.dest_resgion_data.keys():
self.evaluation[name] = NetworkEvaluation()
self.evaluation_2 = {}
for name in self.dest_resgion_data.keys():
self.evaluation_2[name] = NetworkEvaluation()
self.prev_layer_input = defaultdict(lambda : defaultdict(list))
def _addRegion(self, src_name, dest_name, params):
sensor = src_name
sp_name = "sp_" + dest_name
tp_name = "tp_" + dest_name
class_name = "class_" + dest_name
try:
self.network.regions[sp_name]
self.network.regions[tp_name]
self.network.regions[class_name]
self.network.link(sensor, sp_name, "UniformLink", "")
except Exception as e:
# sp
self.network.addRegion(sp_name, "py.SPRegion", json.dumps(params['SP_PARAMS']))
self.network.link(sensor, sp_name, "UniformLink", "")
# tp
self.network.addRegion(tp_name, "py.TPRegion", json.dumps(params['TP_PARAMS']))
self.network.link(sp_name, tp_name, "UniformLink", "")
# class
self.network.addRegion( class_name, "py.CLAClassifierRegion", json.dumps(params['CLASSIFIER_PARAMS']))
self.network.link(tp_name, class_name, "UniformLink", "")
encoder = MultiEncoder()
encoder.addMultipleEncoders(params['CLASSIFIER_ENCODE_PARAMS'])
self.classifier_encoder_list[class_name] = encoder
self.classifier_input_list[class_name] = tp_name
def _initRegion(self, name):
sp_name = "sp_"+ name
tp_name = "tp_"+ name
class_name = "class_"+ name
# setting sp
SP = self.network.regions[sp_name]
SP.setParameter("learningMode", True)
SP.setParameter("anomalyMode", True)
# setting tp
TP = self.network.regions[tp_name]
TP.setParameter("topDownMode", False)
TP.setParameter("learningMode", True)
TP.setParameter("inferenceMode", True)
TP.setParameter("anomalyMode", False)
# classifier regionを定義.
classifier = self.network.regions[class_name]
classifier.setParameter('inferenceMode', True)
classifier.setParameter('learningMode', True)
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 run(self, input_data, learn=True, learn_layer=None):
"""
networkの実行.
学習したいときは, learn=True, ftypeを指定する.
予測したいときは, learn=False, ftypeはNoneを指定する.
学習しているときも, 予測はしているがな.
input_data = {'xy_value': [1.0, 2.0], 'ftype': 'sin'}
"""
self.enable_learning_mode(learn, learn_layer)
self.run_number += 1
# calc encoder, SP, TP
for sensor_name in self.sensor_params.keys():
self.network.regions[sensor_name].getSelf().dataSource.push(input_data)
self.network.run(1)
#self.layer_output(input_data)
#self.debug(input_data)
# learn classifier
inferences = {}
for name in set( itertools.chain.from_iterable( self.net_structure.values() )):
class_name = "class_" + name
inferences['classifier_'+name] = self._learn_classifier_multi(class_name, actValue=input_data['ftype'], pstep=0)
# anomaly
inferences["anomaly"] = self._calc_anomaly()
# output differ
#inferences["output_differ"] = self._calc_output_differ()
# # selectivity
# if input_data['ftype'] is not None and input_data['xy_value'][0] >= 45 and input_data['xy_value'][0] <= 55:
# #self.layer_output(input_data)
# for name in self.dest_resgion_data.keys():
# tp_bottomUpOut = self.network.regions[ "tp_" + name ].getOutputData("bottomUpOut").nonzero()[0]
# self.evaluation[name].save_cell_activity(tp_bottomUpOut, input_data['ftype'])
#
# if input_data['ftype'] is not None and (input_data['xy_value'][0] <= 5 or input_data['xy_value'][0] >= 95):
# for name in self.dest_resgion_data.keys():
# tp_bottomUpOut = self.network.regions[ "tp_" + name ].getOutputData("bottomUpOut").nonzero()[0]
# self.evaluation_2[name].save_cell_activity(tp_bottomUpOut, input_data['ftype'])
return inferences
def _learn_classifier_multi(self, region_name, actValue=None, pstep=0):
"""
classifierの計算を行う.
直接customComputeを呼び出さずに, network.runの中でやりたいところだけど,
計算した内容の取り出し方法がわからない.
"""
# TODO: networkとclassifierを完全に切り分けたいな.
# networkでは, sensor,sp,tpまで計算を行う.
# その計算結果の評価/利用は外に出す.
classifier = self.network.regions[region_name]
encoder = self.classifier_encoder_list[region_name].getEncoderList()[0]
class_input = self.classifier_input_list[region_name]
tp_bottomUpOut = self.network.regions[class_input].getOutputData("bottomUpOut").nonzero()[0]
#tp_bottomUpOut = self.network.regions["TP"].getSelf()._tfdr.infActiveState['t'].reshape(-1).nonzero()[0]
if actValue is not None:
bucketIdx = encoder.getBucketIndices(actValue)[0]
classificationIn = {
'bucketIdx': bucketIdx,
'actValue': actValue
}
else:
classificationIn = {'bucketIdx': 0,'actValue': 'no'}
clResults = classifier.getSelf().customCompute(
recordNum=self.run_number,
patternNZ=tp_bottomUpOut,
classification=classificationIn
)
inferences= self._get_inferences(clResults, pstep, summary_tyep='sum')
return inferences
def _get_inferences(self, clResults, steps, summary_tyep='sum'):
"""
classifierの計算結果を使いやすいように変更するだけ.
"""
likelihoodsVec = clResults[steps]
bucketValues = clResults['actualValues']
likelihoodsDict = defaultdict(int)
bestActValue = None
bestProb = None
if summary_tyep == 'sum':
for (actValue, prob) in zip(bucketValues, likelihoodsVec):
likelihoodsDict[actValue] += prob
if bestProb is None or likelihoodsDict[actValue] > bestProb:
bestProb = likelihoodsDict[actValue]
bestActValue = actValue
elif summary_tyep == 'best':
for (actValue, prob) in zip(bucketValues, likelihoodsVec):
if bestProb is None or prob > bestProb:
likelihoodsDict[actValue] = prob
bestProb = prob
bestActValue = actValue
return {'likelihoodsDict': likelihoodsDict, 'best': {'value': bestActValue, 'prob':bestProb}}
def _calc_output_differ(self):
"""
同じ入力があったときに, 前回の入力との差を計算する.
学習が進んでいるかどうかの指標に出来るかなと思った.
全く同じ: 0
全部違う: 1
"""
score = 0
#self.prev_layer_input = defaultdict(lambda defaultdict(list))
output_differ = {}
for name in set( itertools.chain.from_iterable( self.net_structure.values() )):
tp_input = self.network.regions["tp_"+name].getInputData("bottomUpIn").nonzero()[0]
tp_output = self.network.regions["tp_"+name].getOutputData("bottomUpOut").nonzero()[0]
if self.prev_layer_input[name].has_key(tuple(tp_input)):
prev_output = self.prev_layer_input[name][tuple(tp_input)]
same_cell = (set(prev_output) & set(tp_output))
output_differ[name] = 1 - float(len(same_cell) )/ len(tp_output)
self.prev_layer_input[name][tuple(tp_input)] = tp_output
return output_differ
def _calc_anomaly(self):
"""
各層のanomalyを計算
"""
score = 0
anomalyScore = {}
for name in set( itertools.chain.from_iterable( self.net_structure.values() )):
#sp_bottomUpOut = self.network.regions["sp_"+name].getOutputData("bottomUpOut").nonzero()[0]
sp_bottomUpOut = self.network.regions["tp_"+name].getInputData("bottomUpIn").nonzero()[0]
if self.prevPredictedColumns.has_key(name):
score = computeAnomalyScore(sp_bottomUpOut, self.prevPredictedColumns[name])
#topdown_predict = self.network.regions["TP"].getSelf()._tfdr.topDownCompute().copy().nonzero()[0]
topdown_predict = self.network.regions["tp_"+name].getSelf()._tfdr.topDownCompute().nonzero()[0]
self.prevPredictedColumns[name] = copy.deepcopy(topdown_predict)
anomalyScore[name] = score
return anomalyScore
def reset(self):
"""
reset sequence
"""
for name in set( itertools.chain.from_iterable( self.net_structure.values() )):
self.network.regions["tp_"+name].getSelf().resetSequenceStates()
def enable_learning_mode(self, enable, layer_name = None):
"""
各層のSP, TP, ClassifierのlearningModeを変更
"""
if layer_name is None:
for name in set( itertools.chain.from_iterable( self.net_structure.values() )):
self.network.regions["sp_"+name].setParameter("learningMode", enable)
self.network.regions["tp_"+name].setParameter("learningMode", enable)
self.network.regions["class_"+name].setParameter("learningMode", enable)
else:
for name in set( itertools.chain.from_iterable( self.net_structure.values() )):
self.network.regions["sp_"+name].setParameter("learningMode", not enable)
self.network.regions["tp_"+name].setParameter("learningMode", not enable)
self.network.regions["class_"+name].setParameter("learningMode", not enable)
for name in layer_name:
self.network.regions["sp_"+name].setParameter("learningMode", enable)
self.network.regions["tp_"+name].setParameter("learningMode", enable)
self.network.regions["class_"+name].setParameter("learningMode", enable)
def print_inferences(self, input_data, inferences):
"""
計算結果を出力する
"""
print "%10s, %10s, %1s" % (
int(input_data['xy_value'][0]),
int(input_data['xy_value'][1]),
input_data['ftype'][:1]),
for name in sorted(self.dest_resgion_data.keys()):
print "%1s" % (inferences['classifier_'+name]['best']['value'][:1]),
for name in sorted(self.dest_resgion_data.keys()):
print "%6.4f," % (inferences['classifier_'+name]['likelihoodsDict'][input_data['ftype']]),
for name in sorted(self.dest_resgion_data.keys()):
print "%3.2f," % (inferences["anomaly"][name]),
# for name in sorted(self.dest_resgion_data.keys()):
# print "%5s," % name,
print
def layer_output(self, input_data, region_name=None):
if region_name is not None:
Region = self.network.regions[region_name]
print Region.getOutputData("bottomUpOut").nonzero()[0]
return
for name in self.dest_resgion_data.keys():
SPRegion = self.network.regions["sp_"+name]
TPRegion = self.network.regions["tp_"+name]
print "#################################### ", name
print
print "==== SP layer ===="
print "input: ", SPRegion.getInputData("bottomUpIn").nonzero()[0]
print "output: ", SPRegion.getOutputData("bottomUpOut").nonzero()[0]
print
print "==== TP layer ===="
print "input: ", TPRegion.getInputData("bottomUpIn").nonzero()[0]
print "output: ", TPRegion.getOutputData("bottomUpOut").nonzero()[0]
print
print "==== Predict ===="
print TPRegion.getSelf()._tfdr.topDownCompute().copy().nonzero()[0][:10]
print
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 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)
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 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 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(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 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 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)
class HTMusicModel(object):
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 _link_all_regions(self):
# Linking regions
self.network.link('DurationEncoder', 'SpatialPooler', 'UniformLink',
'')
self.network.link('VelocityEncoder', 'SpatialPooler', 'UniformLink',
'')
self.network.link('PitchEncoder', 'SpatialPooler', 'UniformLink', '')
self.network.link('SpatialPooler',
'TemporalMemory',
'UniformLink',
'',
srcOutput='bottomUpOut',
destInput='bottomUpIn')
def _enable_learning(self):
# Enable learning for all regions.
self.network.regions["SpatialPooler"].setParameter("learningMode", 1)
self.network.regions["TemporalMemory"].setParameter("learningMode", 1)
def _enable_inference(self):
# Enable inference for all regions.
self.network.regions["SpatialPooler"].setParameter("inferenceMode", 1)
self.network.regions["TemporalMemory"].setParameter("inferenceMode", 1)
def train(self, duration, pitch, velocity):
records_total = self.network.regions['SpatialPooler'].getSelf(
).getAlgorithmInstance().getIterationNum()
self.network.regions['DurationEncoder'].setParameter(
'sensedValue', duration)
self.network.regions['PitchEncoder'].setParameter('sensedValue', pitch)
self.network.regions['VelocityEncoder'].setParameter(
'sensedValue', velocity)
self.network.run(1)
# Getting active cells of TM and bucket indicies of encoders to feed classifiers
active_cells = numpy.array(
self.network.regions['TemporalMemory'].getOutputData(
'bottomUpOut')).nonzero()[0]
duration_bucket = numpy.array(
self.network.regions['DurationEncoder'].getOutputData('bucket'))
pitch_bucket = numpy.array(
self.network.regions['PitchEncoder'].getOutputData('bucket'))
velocity_bucket = numpy.array(
self.network.regions['VelocityEncoder'].getOutputData('bucket'))
duration_classifier_result = self.duration_classifier.compute(
recordNum=records_total,
patternNZ=active_cells,
classification={
'bucketIdx': duration_bucket[0],
'actValue': duration
},
learn=True,
infer=False)
pitch_classifier_result = self.pitch_classifier.compute(
recordNum=records_total,
patternNZ=active_cells,
classification={
'bucketIdx': pitch_bucket[0],
'actValue': pitch
},
learn=True,
infer=False)
velocity_classifier_result = self.velocity_classifier.compute(
recordNum=records_total,
patternNZ=active_cells,
classification={
'bucketIdx': velocity_bucket[0],
'actValue': velocity
},
learn=True,
infer=False)
def generate(self, seed, output_dir, event_amount):
records_total = self.network.regions['SpatialPooler'].getSelf(
).getAlgorithmInstance().getIterationNum()
seed = seed
midi = pretty_midi.PrettyMIDI()
midi_program = pretty_midi.instrument_name_to_program(
'Acoustic Grand Piano')
piano = pretty_midi.Instrument(program=midi_program)
clock = 0
for iters in tqdm(range(records_total, records_total + event_amount)):
duration = seed[0]
pitch = seed[1]
velocity = seed[2]
self.network.regions['DurationEncoder'].setParameter(
'sensedValue', duration)
self.network.regions['PitchEncoder'].setParameter(
'sensedValue', pitch)
self.network.regions['VelocityEncoder'].setParameter(
'sensedValue', velocity)
self.network.run(1)
# Getting active cells of TM and bucket indicies of encoders to feed classifiers
active_cells = numpy.array(
self.network.regions['TemporalMemory'].getOutputData(
'bottomUpOut')).nonzero()[0]
duration_bucket = numpy.array(
self.network.regions['DurationEncoder'].getOutputData(
'bucket'))
pitch_bucket = numpy.array(
self.network.regions['PitchEncoder'].getOutputData('bucket'))
velocity_bucket = numpy.array(
self.network.regions['VelocityEncoder'].getOutputData(
'bucket'))
# Getting up classifiers result
duration_classifier_result = self.duration_classifier.compute(
recordNum=records_total,
patternNZ=active_cells,
classification={
'bucketIdx': duration_bucket[0],
'actValue': duration
},
learn=False,
infer=True)
pitch_classifier_result = self.pitch_classifier.compute(
recordNum=records_total,
patternNZ=active_cells,
classification={
'bucketIdx': pitch_bucket[0],
'actValue': pitch
},
learn=False,
infer=True)
velocity_classifier_result = self.velocity_classifier.compute(
recordNum=records_total,
patternNZ=active_cells,
classification={
'bucketIdx': velocity_bucket[0],
'actValue': velocity
},
learn=False,
infer=True)
du = duration_classifier_result[1].argmax()
pi = pitch_classifier_result[1].argmax()
ve = velocity_classifier_result[1].argmax()
duration_top_probs = duration_classifier_result[1][
0:2] / duration_classifier_result[1][0:2].sum()
predicted_duration = duration_classifier_result['actualValues'][du]
# predicted_duration = duration_classifier_result['actualValues'][du]
predicted_pitch = pitch_classifier_result['actualValues'][pi]
predicted_velocity = velocity_classifier_result['actualValues'][ve]
# print duration_classifier_result
note = pretty_midi.Note(velocity=int(predicted_velocity),
pitch=int(predicted_pitch),
start=float(clock),
end=float(clock + predicted_duration))
piano.notes.append(note)
clock = clock + 0.25
seed[0] = predicted_duration
seed[1] = predicted_pitch
seed[2] = predicted_velocity
midi.instruments.append(piano)
midi.remove_invalid_notes()
time = datetime.datetime.now().strftime('%Y-%m-%d %H:%m:%S')
midi.write(output_dir + time + '.mid')
def load_model(self, load_path):
# Loading SpatialPooler
print 'Loading SpatialPooler'
with open(load_path + 'sp.bin', 'rb') as sp:
sp_builder = SpatialPoolerProto.read(
sp, traversal_limit_in_words=2**61)
self.network.regions['SpatialPooler'].getSelf(
)._sfdr = self.network.regions['SpatialPooler'].getSelf()._sfdr.read(
sp_builder)
# Loading TemporalMemory
print 'Loading TemporalMemory'
self.network.regions['TemporalMemory'].getSelf().getAlgorithmInstance(
).loadFromFile(load_path + 'tm.bin')
# Loading end classifier
print 'Loading duration classifier'
with open(load_path + 'dcl.bin', 'rb') as dcl:
dcl_builder = SdrClassifierProto.read(
dcl, traversal_limit_in_words=2**61)
self.duration_classifier = self.duration_classifier.read(dcl_builder)
# Loading pitch classifier
print 'Loading pitch classifier'
with open(load_path + 'pcl.bin', 'rb') as pcl:
pcl_builder = SdrClassifierProto.read(
pcl, traversal_limit_in_words=2**61)
self.pitch_classifier = self.pitch_classifier.read(pcl_builder)
# Loading velocity classifier
print 'Loading velocity classifier'
with open(load_path + 'vcl.bin', 'rb') as vcl:
vcl_builder = SdrClassifierProto.read(
vcl, traversal_limit_in_words=2**61)
self.velocity_classifier = self.velocity_classifier.read(vcl_builder)
def save_model(self, save_path):
# Saving SpatialPooler
print 'Saving SpatialPooler'
sp_builder = SpatialPoolerProto.new_message()
self.network.regions['SpatialPooler'].getSelf().getAlgorithmInstance(
).write(sp_builder)
with open(save_path + 'sp.bin', 'w+b') as sp:
sp_builder.write(sp)
# Saving TemporalMemory
print 'Saving TemporalMemory'
self.network.regions['TemporalMemory'].getSelf().getAlgorithmInstance(
).saveToFile(save_path + 'tm.bin')
# Saving end classifier
print 'Saving duration classifier'
dcl_builder = SdrClassifierProto.new_message()
self.duration_classifier.write(dcl_builder)
with open(save_path + 'dcl.bin', 'w+b') as dcl:
dcl_builder.write(dcl)
# Saving pitch classifier
print 'Saving pitch classifier'
pcl_builder = SdrClassifierProto.new_message()
self.pitch_classifier.write(pcl_builder)
with open(save_path + 'pcl.bin', 'w+b') as pcl:
pcl_builder.write(pcl)
# Saving velocity classifier
print 'Saving velocity classifier'
vcl_builder = SdrClassifierProto.new_message()
self.velocity_classifier.write(vcl_builder)
with open(save_path + 'vcl.bin', 'w+b') as vcl:
vcl_builder.write(vcl)
def createNetwork(dataSource):
"""
networkを作成する.
sensor, sp, tp
"""
network = Network()
# create sensor region
# create sensor region
network.addRegion("sensor", "py.RecordSensor",
json.dumps({"verbosity": 0}))
sensor = network.regions["sensor"].getSelf()
sensor.encoder = createEncoder()
sensor.disabledEncoder = createCategoryEncoder()
#sensor.dataSource = dataSource
sensor.dataSource = DataBuffer()
# create spacial pooler region
print sensor.encoder.getWidth()
SP_PARAMS["inputWidth"] = sensor.encoder.getWidth()
network.addRegion("SP", "py.SPRegion", json.dumps(SP_PARAMS))
# linke sensor input <-> SP Region
# Resion毎のinput/output名は, regions下の, SPRegion.py, TPRegion.py, RecordSensor.py
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")
# create temporal pooler region
network.addRegion("TP", "py.TPRegion",
json.dumps(TP_PARAMS))
network.link("SP", "TP", "UniformLink", "")
network.link("TP", "SP", "UniformLink", "", # これ, なくしても何も変化なかったけど..
srcOutput="topDownOut", destInput="topDownIn")
# create classifier
network.addRegion("Classifier", "py.CLAClassifierRegion",
json.dumps(CLASSIFIER_PARAMS))
network.link("TP", "Classifier", "UniformLink", "")
network.link("sensor", "Classifier", "UniformLink", "",
srcOutput="categoryOut", destInput="categoryIn")
# initialize
network.initialize()
# setting sp
SP = network.regions["SP"]
SP.setParameter("learningMode", True)
SP.setParameter("anomalyMode", True)
# setting tp
TP = network.regions["TP"]
TP.setParameter("topDownMode", False)
TP.setParameter("learningMode", True)
TP.setParameter("inferenceMode", True)
# OPFでやってるみたいな, AnomalyClassifierを追加するやり方とちがうのか.
TP.setParameter("anomalyMode", False)
# classifier regionを定義.
classifier = network.regions["Classifier"]
classifier.setParameter('inferenceMode', True)
classifier.setParameter('learningMode', True)
return network
def testCreateL4L6aLocationColumn(self):
"""
Test 'createL4L6aLocationColumn' by inferring a set of hand crafted objects
"""
scale = []
orientation = []
# Initialize L6a location region with 5 modules varying scale by sqrt(2) and
# 4 different random orientations for each scale
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))
net = Network()
createL4L6aLocationColumn(net, {
"inverseReadoutResolution": 8,
"sensorInputSize": NUM_OF_CELLS,
"L4Params": {
"columnCount": NUM_OF_COLUMNS,
"cellsPerColumn": CELLS_PER_COLUMN,
"activationThreshold": 15,
"minThreshold": 15,
"initialPermanence": 1.0,
"implementation": "ApicalTiebreak",
"maxSynapsesPerSegment": -1
},
"L6aParams": {
"moduleCount": len(scale),
"scale": scale,
"orientation": orientation,
"anchorInputSize": NUM_OF_CELLS,
"activationThreshold": 8,
"initialPermanence": 1.0,
"connectedPermanence": 0.5,
"learningThreshold": 8,
"sampleSize": 10,
"permanenceIncrement": 0.1,
"permanenceDecrement": 0.0,
"bumpOverlapMethod": "probabilistic"
}
})
net.initialize()
L4 = net.regions['L4']
L6a = net.regions['L6a']
sensor = net.regions['sensorInput'].getSelf()
motor = net.regions['motorInput'].getSelf()
# Keeps a list of learned objects
learnedRepresentations = defaultdict(list)
# Learn Objects
self._setLearning(net, True)
for objectDescription in OBJECTS:
reset = True
previousLocation = None
L6a.executeCommand(["activateRandomLocation"])
for iFeature, feature in enumerate(objectDescription["features"]):
# Move the sensor to the center of the object
locationOnObject = np.array([feature["top"] + feature["height"] / 2.,
feature["left"] + feature["width"] / 2.])
# Calculate displacement from previous location
if previousLocation is not None:
motor.addDataToQueue(locationOnObject - previousLocation)
previousLocation = locationOnObject
# Sense feature at location
sensor.addDataToQueue(FEATURE_ACTIVE_COLUMNS[feature["name"]], reset, 0)
net.run(1)
reset = False
# Save learned representations
representation = L6a.getOutputData("sensoryAssociatedCells")
representation = representation.nonzero()[0]
learnedRepresentations[
(objectDescription["name"], iFeature)] = representation
# Infer objects
self._setLearning(net, False)
for objectDescription in OBJECTS:
reset = True
previousLocation = None
inferred = False
features = objectDescription["features"]
touchSequence = range(len(features))
random.shuffle(touchSequence)
for iFeature in touchSequence:
feature = features[iFeature]
# Move the sensor to the center of the object
locationOnObject = np.array([feature["top"] + feature["height"] / 2.,
feature["left"] + feature["width"] / 2.])
# Calculate displacement from previous location
if previousLocation is not None:
motor.addDataToQueue(locationOnObject - previousLocation)
previousLocation = locationOnObject
# Sense feature at location
sensor.addDataToQueue(FEATURE_ACTIVE_COLUMNS[feature["name"]], reset, 0)
net.run(1)
reset = False
representation = L6a.getOutputData("sensoryAssociatedCells")
representation = representation.nonzero()[0]
target_representations = set(
learnedRepresentations[(objectDescription["name"], iFeature)])
inferred = (set(representation) <= target_representations)
if inferred:
break
self.assertTrue(inferred)
class FunctionRecogniter():
def __init__(self):
from collections import OrderedDict
self.run_number = 0
# for classifier
self.classifier_encoder_list = {}
self.classifier_input_list = {}
self.prevPredictedColumns = {}
self.selectivity = "region1"
# net structure
self.net_structure = OrderedDict()
self.net_structure['sensor1'] = ['region1']
# self.net_structure['sensor2'] = ['region2']
# self.net_structure['sensor3'] = ['region3']
# self.net_structure['region1'] = ['region4']
# self.net_structure['region2'] = ['region4']
# sensor change params
self.sensor_params = {
'sensor1': {
'xy_value': {
'maxval': 100.0,
'minval': 0.0
},
},
# 'sensor2': {
# 'xy_value': {
# 'maxval': 80.0,
# 'minval': 20.0
# },
# },
# 'sensor3': {
# 'xy_value': {
# 'maxval': 100.0,
# 'minval': 40.0
# },
# },
}
# region change params
self.dest_resgion_data = {
'region1': {
'SP_PARAMS':{
"columnCount": 2024,
"numActiveColumnsPerInhArea": 20,
},
'TP_PARAMS':{
"cellsPerColumn": 16
},
},
# 'region2': {
# 'TP_PARAMS':{
# "cellsPerColumn": 8
# },
# },
# 'region3': {
# 'TP_PARAMS':{
# "cellsPerColumn": 8
# },
# },
# 'region4': {
# 'SP_PARAMS':{
# "inputWidth": 2024 * (4 + 8)
# },
# 'TP_PARAMS':{
# "cellsPerColumn": 16
# },
# },
}
self._createNetwork()
# for evaluate netwrok accuracy
self.evaluation = NetworkEvaluation()
def _addRegion(self, src_name, dest_name, params):
import json
from nupic.encoders import MultiEncoder
sensor = src_name
sp_name = "sp_" + dest_name
tp_name = "tp_" + dest_name
class_name = "class_" + dest_name
try:
self.network.regions[sp_name]
self.network.regions[tp_name]
self.network.regions[class_name]
self.network.link(sensor, sp_name, "UniformLink", "")
except Exception as e:
# sp
self.network.addRegion(sp_name, "py.SPRegion", json.dumps(params['SP_PARAMS']))
self.network.link(sensor, sp_name, "UniformLink", "")
# tp
self.network.addRegion(tp_name, "py.TPRegion", json.dumps(params['TP_PARAMS']))
self.network.link(sp_name, tp_name, "UniformLink", "")
# class
self.network.addRegion( class_name, "py.CLAClassifierRegion", json.dumps(params['CLASSIFIER_PARAMS']))
self.network.link(tp_name, class_name, "UniformLink", "")
encoder = MultiEncoder()
encoder.addMultipleEncoders(params['CLASSIFIER_ENCODE_PARAMS'])
self.classifier_encoder_list[class_name] = encoder
self.classifier_input_list[class_name] = tp_name
def _initRegion(self, name):
sp_name = "sp_"+ name
tp_name = "tp_"+ name
class_name = "class_"+ name
# setting sp
SP = self.network.regions[sp_name]
SP.setParameter("learningMode", True)
SP.setParameter("anomalyMode", True)
# setting tp
TP = self.network.regions[tp_name]
TP.setParameter("topDownMode", False)
TP.setParameter("learningMode", True)
TP.setParameter("inferenceMode", True)
TP.setParameter("anomalyMode", False)
# classifier regionを定義.
classifier = self.network.regions[class_name]
classifier.setParameter('inferenceMode', True)
classifier.setParameter('learningMode', True)
def _createNetwork(self):
def deepupdate(original, update):
"""
Recursively update a dict.
Subdict's won't be overwritten but also updated.
"""
for key, value in original.iteritems():
if not key in update:
update[key] = value
elif isinstance(value, dict):
deepupdate(value, update[key])
return update
from nupic.algorithms.anomaly import computeAnomalyScore
from nupic.encoders import MultiEncoder
from nupic.engine import Network
import create_network as cn
import json
import itertools
self.network = Network()
# 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("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 run(self, input_data, learn=True):
"""
networkの実行.
学習したいときは, learn=True, ftypeを指定する.
予測したいときは, learn=False, ftypeはNoneを指定する.
学習しているときも, 予測はしているがな.
input_data = {'xy_value': [1.0, 2.0], 'ftype': 'sin'}
"""
import itertools
self.enable_learning_mode(learn)
self.run_number += 1
# calc encoder, SP, TP
for sensor_name in self.sensor_params.keys():
self.network.regions[sensor_name].getSelf().dataSource.push(input_data)
self.network.run(1)
#self.layer_output(input_data)
#self.debug(input_data)
# learn classifier
inferences = {}
for name in set( itertools.chain.from_iterable( self.net_structure.values() )):
class_name = "class_" + name
inferences['classifier_'+name] = self._learn_classifier_multi(class_name, actValue=input_data['ftype'], pstep=0)
# anomaly
inferences["anomaly"] = self._calc_anomaly()
# selectivity
if input_data['ftype'] is not None and inferences["anomaly"][self.selectivity] < 0.7:
#if input_data['ftype'] is not None and input_data['xy_value'][0] > 40 and input_data['xy_value'][0] < 60:
tp_bottomUpOut = self.network.regions[ "tp_" + self.selectivity ].getOutputData("bottomUpOut").nonzero()[0]
self.evaluation.save_cell_activity(tp_bottomUpOut, input_data['ftype'])
return inferences
def _learn_classifier_multi(self, region_name, actValue=None, pstep=0):
"""
classifierの計算を行う.
直接customComputeを呼び出さずに, network.runの中でやりたいところだけど,
計算した内容の取り出し方法がわからない.
"""
# TODO: networkとclassifierを完全に切り分けたいな.
# networkでは, sensor,sp,tpまで計算を行う.
# その計算結果の評価/利用は外に出す.
classifier = self.network.regions[region_name]
encoder = self.classifier_encoder_list[region_name].getEncoderList()[0]
class_input = self.classifier_input_list[region_name]
tp_bottomUpOut = self.network.regions[class_input].getOutputData("bottomUpOut").nonzero()[0]
#tp_bottomUpOut = self.network.regions["TP"].getSelf()._tfdr.infActiveState['t'].reshape(-1).nonzero()[0]
if actValue is not None:
bucketIdx = encoder.getBucketIndices(actValue)[0]
classificationIn = {
'bucketIdx': bucketIdx,
'actValue': actValue
}
else:
classificationIn = {'bucketIdx': 0,'actValue': 'no'}
clResults = classifier.getSelf().customCompute(
recordNum=self.run_number,
patternNZ=tp_bottomUpOut,
classification=classificationIn
)
inferences= self._get_inferences(clResults, pstep, summary_tyep='sum')
return inferences
def _get_inferences(self, clResults, steps, summary_tyep='sum'):
"""
classifierの計算結果を使いやすいように変更するだけ.
"""
from collections import defaultdict
likelihoodsVec = clResults[steps]
bucketValues = clResults['actualValues']
likelihoodsDict = defaultdict(int)
bestActValue = None
bestProb = None
if summary_tyep == 'sum':
for (actValue, prob) in zip(bucketValues, likelihoodsVec):
likelihoodsDict[actValue] += prob
if bestProb is None or likelihoodsDict[actValue] > bestProb:
bestProb = likelihoodsDict[actValue]
bestActValue = actValue
elif summary_tyep == 'best':
for (actValue, prob) in zip(bucketValues, likelihoodsVec):
if bestProb is None or prob > bestProb:
likelihoodsDict[actValue] = prob
bestProb = prob
bestActValue = actValue
return {'likelihoodsDict': likelihoodsDict, 'best': {'value': bestActValue, 'prob':bestProb}}
def _calc_anomaly(self):
"""
各層のanomalyを計算
"""
import copy
import itertools
from nupic.algorithms.anomaly import computeAnomalyScore
score = 0
anomalyScore = {}
for name in set( itertools.chain.from_iterable( self.net_structure.values() )):
sp_bottomUpOut = self.network.regions["sp_"+name].getOutputData("bottomUpOut").nonzero()[0]
if self.prevPredictedColumns.has_key(name):
score = computeAnomalyScore(sp_bottomUpOut, self.prevPredictedColumns[name])
#topdown_predict = self.network.regions["TP"].getSelf()._tfdr.topDownCompute().copy().nonzero()[0]
topdown_predict = self.network.regions["tp_"+name].getSelf()._tfdr.topDownCompute().nonzero()[0]
self.prevPredictedColumns[name] = copy.deepcopy(topdown_predict)
anomalyScore[name] = score
return anomalyScore
def reset(self):
"""
reset sequence
"""
import itertools
for name in set( itertools.chain.from_iterable( self.net_structure.values() )):
self.network.regions["tp_"+name].getSelf().resetSequenceStates()
def enable_learning_mode(self, enable):
"""
各層のSP, TP, ClassifierのlearningModeを変更
"""
import itertools
for name in set( itertools.chain.from_iterable( self.net_structure.values() )):
self.network.regions["sp_"+name].setParameter("learningMode", enable)
self.network.regions["tp_"+name].setParameter("learningMode", enable)
self.network.regions["class_"+name].setParameter("learningMode", enable)
def print_inferences(self, input_data, inferences):
"""
計算結果を出力する
"""
import itertools
print "%10s, %10s, %5s" % (
int(input_data['xy_value'][0]),
int(input_data['xy_value'][1]),
input_data['ftype']),
for name in set( itertools.chain.from_iterable( self.net_structure.values() )):
print "%5s," % (inferences['classifier_'+name]['best']['value']),
for name in set( itertools.chain.from_iterable( self.net_structure.values() )):
print "%10.6f," % (inferences['classifier_'+name]['likelihoodsDict'][input_data['ftype']]),
for name in set( itertools.chain.from_iterable( self.net_structure.values() )):
print "%5s," % (str(inferences["anomaly"][name])),
print
def reset(self, params, repetition):
"""
Take the steps necessary to reset the experiment before each repetition:
- Make sure random seed is different for each repetition
- Create the L2-L4-L6a network
- Generate objects used by the experiment
- Learn all objects used by the experiment
"""
print params["name"], ":", repetition
self.debug = params.get("debug", False)
L2Params = json.loads('{' + params["l2_params"] + '}')
L4Params = json.loads('{' + params["l4_params"] + '}')
L6aParams = json.loads('{' + params["l6a_params"] + '}')
# Make sure random seed is different for each repetition
seed = params.get("seed", 42)
np.random.seed(seed + repetition)
random.seed(seed + repetition)
L2Params["seed"] = seed + repetition
L4Params["seed"] = seed + repetition
L6aParams["seed"] = seed + repetition
# Configure L6a params
numModules = params["num_modules"]
L6aParams["scale"] = [params["scale"]] * numModules
angle = params["angle"] / numModules
orientation = range(angle / 2, angle * numModules, angle)
L6aParams["orientation"] = np.radians(orientation).tolist()
# Create multi-column L2-L4-L6a network
self.numColumns = params["num_cortical_columns"]
network = Network()
network = createMultipleL246aLocationColumn(
network=network,
numberOfColumns=self.numColumns,
L2Params=L2Params,
L4Params=L4Params,
L6aParams=L6aParams)
network.initialize()
self.network = network
self.sensorInput = []
self.motorInput = []
self.L2Regions = []
self.L4Regions = []
self.L6aRegions = []
for i in xrange(self.numColumns):
col = str(i)
self.sensorInput.append(network.regions["sensorInput_" +
col].getSelf())
self.motorInput.append(network.regions["motorInput_" +
col].getSelf())
self.L2Regions.append(network.regions["L2_" + col])
self.L4Regions.append(network.regions["L4_" + col])
self.L6aRegions.append(network.regions["L6a_" + col])
# Use the number of iterations as the number of objects. This will allow us
# to execute one iteration per object and use the "iteration" parameter as
# the object index
numObjects = params["iterations"]
# Generate feature SDRs
numFeatures = params["num_features"]
numOfMinicolumns = L4Params["columnCount"]
numOfActiveMinicolumns = params["num_active_minicolumns"]
self.featureSDR = [{
str(f):
sorted(np.random.choice(numOfMinicolumns, numOfActiveMinicolumns))
for f in xrange(numFeatures)
} for _ in xrange(self.numColumns)]
# Generate objects used in the experiment
self.objects = generateObjects(
numObjects=numObjects,
featuresPerObject=params["features_per_object"],
objectWidth=params["object_width"],
numFeatures=numFeatures,
distribution=params["feature_distribution"])
# Make sure the objects are unique
uniqueObjs = np.unique([{
"features": obj["features"]
} for obj in self.objects])
assert len(uniqueObjs) == len(self.objects)
self.sdrSize = L2Params["sdrSize"]
# Learn objects
self.numLearningPoints = params["num_learning_points"]
self.numOfSensations = params["num_sensations"]
self.learnedObjects = {}
self.learn()
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)
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")
# Add the AnomalyRegion on top of the TPRegion
network.addRegion("anomalyRegion", "py.AnomalyRegion", json.dumps({}))
network.link("spatialPoolerRegion", "anomalyRegion", "UniformLink", "",
srcOutput="bottomUpOut", destInput="activeColumns")
network.link("temporalPoolerRegion", "anomalyRegion", "UniformLink", "",
srcOutput="topDownOut", destInput="predictedColumns")
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 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
class ClaClassifier():
def __init__(self, net_structure, sensor_params, dest_region_params,
class_encoder_params):
self.run_number = 0
# for classifier
self.classifier_encoder_list = {}
self.classifier_input_list = {}
self.prevPredictedColumns = {}
# TODO: 消したいパラメータ
self.predict_value = class_encoder_params.keys()[0]
self.predict_step = 0
# default param
self.default_params = {
'SP_PARAMS': {
"spVerbosity": 0,
"spatialImp": "cpp",
"globalInhibition": 1,
"columnCount": 2024,
"inputWidth": 0, # set later
"numActiveColumnsPerInhArea": 20,
"seed": 1956,
"potentialPct": 0.8,
"synPermConnected": 0.1,
"synPermActiveInc": 0.05,
"synPermInactiveDec": 0.0005,
"maxBoost": 2.0,
},
'TP_PARAMS': {
"verbosity": 0,
"columnCount": 2024,
"cellsPerColumn": 32,
"inputWidth": 2024,
"seed": 1960,
"temporalImp": "cpp",
"newSynapseCount": 20,
"maxSynapsesPerSegment": 32,
"maxSegmentsPerCell": 128,
"initialPerm": 0.21,
"permanenceInc": 0.2,
"permanenceDec": 0.1,
"globalDecay": 0.0,
"maxAge": 0,
"minThreshold": 12,
"activationThreshold": 16,
"outputType": "normal",
"pamLength": 1,
},
'CLASSIFIER_PARAMS': {
"clVerbosity": 0,
"alpha": 0.005,
"steps": "0"
}
}
# tp
self.tp_enable = True
# net structure
self.net_structure = OrderedDict()
self.net_structure['sensor3'] = ['region1']
self.net_structure['region1'] = ['region2']
self.net_structure = net_structure
# region change params
self.dest_region_params = dest_region_params
# sensor change params
self.sensor_params = sensor_params
self.class_encoder_params = class_encoder_params
self._createNetwork()
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 _linkRegion(self, src_name, dest_name):
sensor = src_name
sp_name = "sp_" + dest_name
tp_name = "tp_" + dest_name
class_name = "class_" + dest_name
if self.tp_enable:
self.network.link(sensor, sp_name, "UniformLink", "")
self.network.link(sp_name, tp_name, "UniformLink", "")
self.network.link(tp_name, class_name, "UniformLink", "")
else:
self.network.link(sensor, sp_name, "UniformLink", "")
self.network.link(sp_name, class_name, "UniformLink", "")
def _initRegion(self, name):
sp_name = "sp_" + name
tp_name = "tp_" + name
class_name = "class_" + name
# setting sp
SP = self.network.regions[sp_name]
SP.setParameter("learningMode", True)
SP.setParameter("anomalyMode", True)
# # setting tp
if self.tp_enable:
TP = self.network.regions[tp_name]
TP.setParameter("topDownMode", False)
TP.setParameter("learningMode", True)
TP.setParameter("inferenceMode", True)
TP.setParameter("anomalyMode", False)
# classifier regionを定義.
classifier = self.network.regions[class_name]
classifier.setParameter('inferenceMode', True)
classifier.setParameter('learningMode', True)
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
#@profile
def run(self, input_data, learn=True, class_learn=True, learn_layer=None):
"""
networkの実行.
学習したいときは, learn=True, ftypeを指定する.
予測したいときは, learn=False, ftypeはNoneを指定する.
学習しているときも, 予測はしているがな.
input_data = {'xy_value': [1.0, 2.0], 'ftype': 'sin'}
"""
self.enable_learning_mode(learn, learn_layer)
self.enable_class_learning_mode(class_learn)
self.run_number += 1
# calc encoder, SP, TP
for sensor_name in self.sensor_params.keys():
self.network.regions[sensor_name].getSelf().dataSource.push(
input_data)
self.network.run(1)
#self.layer_output(input_data)
#self.debug(input_data)
# learn classifier
inferences = {}
for name in self.dest_region_params.keys():
class_name = "class_" + name
inferences['classifier_' + name] = self._learn_classifier_multi(
class_name,
actValue=input_data[self.predict_value],
pstep=self.predict_step)
# anomaly
#inferences["anomaly"] = self._calc_anomaly()
return inferences
def _learn_classifier_multi(self, region_name, actValue=None, pstep=0):
"""
classifierの計算を行う.
直接customComputeを呼び出さずに, network.runの中でやりたいところだけど,
計算した内容の取り出し方法がわからない.
"""
# TODO: networkとclassifierを完全に切り分けたいな.
# networkでは, sensor,sp,tpまで計算を行う.
# その計算結果の評価/利用は外に出す.
classifier = self.network.regions[region_name]
encoder = self.classifier_encoder_list[region_name].getEncoderList()[0]
class_input = self.classifier_input_list[region_name]
tp_bottomUpOut = self.network.regions[class_input].getOutputData(
"bottomUpOut").nonzero()[0]
#tp_bottomUpOut = self.network.regions["TP"].getSelf()._tfdr.infActiveState['t'].reshape(-1).nonzero()[0]
if actValue is not None:
bucketIdx = encoder.getBucketIndices(actValue)[0]
classificationIn = {'bucketIdx': bucketIdx, 'actValue': actValue}
else:
classificationIn = {'bucketIdx': 0, 'actValue': 'no'}
clResults = classifier.getSelf().customCompute(
recordNum=self.run_number,
patternNZ=tp_bottomUpOut,
classification=classificationIn)
inferences = self._get_inferences(clResults, pstep, summary_tyep='sum')
return inferences
def _get_inferences(self, clResults, steps, summary_tyep='sum'):
"""
classifierの計算結果を使いやすいように変更するだけ.
"""
likelihoodsVec = clResults[steps]
bucketValues = clResults['actualValues']
likelihoodsDict = defaultdict(int)
bestActValue = None
bestProb = None
if summary_tyep == 'sum':
for (actValue, prob) in zip(bucketValues, likelihoodsVec):
likelihoodsDict[actValue] += prob
if bestProb is None or likelihoodsDict[actValue] > bestProb:
bestProb = likelihoodsDict[actValue]
bestActValue = actValue
elif summary_tyep == 'best':
for (actValue, prob) in zip(bucketValues, likelihoodsVec):
if bestProb is None or prob > bestProb:
likelihoodsDict[actValue] = prob
bestProb = prob
bestActValue = actValue
return {
'likelihoodsDict': likelihoodsDict,
'best': {
'value': bestActValue,
'prob': bestProb
}
}
def _calc_anomaly(self):
"""
各層のanomalyを計算
"""
score = 0
anomalyScore = {}
for name in self.dest_region_params.keys():
#sp_bottomUpOut = self.network.regions["sp_"+name].getOutputData("bottomUpOut").nonzero()[0]
sp_bottomUpOut = self.network.regions["tp_" + name].getInputData(
"bottomUpIn").nonzero()[0]
if self.prevPredictedColumns.has_key(name):
score = computeAnomalyScore(sp_bottomUpOut,
self.prevPredictedColumns[name])
#topdown_predict = self.network.regions["TP"].getSelf()._tfdr.topDownCompute().copy().nonzero()[0]
topdown_predict = self.network.regions[
"tp_" + name].getSelf()._tfdr.topDownCompute().nonzero()[0]
self.prevPredictedColumns[name] = copy.deepcopy(topdown_predict)
anomalyScore[name] = score
return anomalyScore
def reset(self):
"""
reset sequence
"""
# for name in self.dest_region_params.keys():
# self.network.regions["tp_"+name].getSelf().resetSequenceStates()
return
# for sensor_name in self.sensor_params.keys():
# sensor = self.network.regions[sensor_name].getSelf()
# sensor.dataSource = DataBuffer()
def enable_class_learning_mode(self, enable):
for name in self.dest_region_params.keys():
self.network.regions["class_" + name].setParameter(
"learningMode", enable)
def enable_learning_mode(self, enable, layer_name=None):
"""
各層のSP, TP, ClassifierのlearningModeを変更
"""
if layer_name is None:
for name in self.dest_region_params.keys():
self.network.regions["sp_" + name].setParameter(
"learningMode", enable)
if self.tp_enable:
self.network.regions["tp_" + name].setParameter(
"learningMode", enable)
self.network.regions["class_" + name].setParameter(
"learningMode", enable)
else:
for name in self.dest_region_params.keys():
self.network.regions["sp_" + name].setParameter(
"learningMode", not enable)
if self.tp_enable:
self.network.regions["tp_" + name].setParameter(
"learningMode", not enable)
self.network.regions["class_" + name].setParameter(
"learningMode", not enable)
for name in layer_name:
self.network.regions["sp_" + name].setParameter(
"learningMode", enable)
if self.tp_enable:
self.network.regions["tp_" + name].setParameter(
"learningMode", enable)
self.network.regions["class_" + name].setParameter(
"learningMode", enable)
def print_inferences(self, input_data, inferences):
"""
計算結果を出力する
"""
# print "%10s, %10s, %1s" % (
# int(input_data['xy_value'][0]),
# int(input_data['xy_value'][1]),
# input_data['label'][:1]),
print "%5s" % (input_data['label']),
try:
for name in sorted(self.dest_region_params.keys()):
print "%5s" % (inferences['classifier_' +
name]['best']['value']),
for name in sorted(self.dest_region_params.keys()):
print "%6.4f," % (inferences['classifier_' +
name]['likelihoodsDict']
[input_data[self.predict_value]]),
except:
pass
# for name in sorted(self.dest_region_params.keys()):
# print "%3.2f," % (inferences["anomaly"][name]),
# for name in sorted(self.dest_region_params.keys()):
# print "%5s," % name,
print
def layer_output(self, input_data, region_name=None):
if region_name is not None:
Region = self.network.regions[region_name]
print Region.getOutputData("bottomUpOut").nonzero()[0]
return
for name in self.dest_region_params.keys():
SPRegion = self.network.regions["sp_" + name]
if self.tp_enable:
TPRegion = self.network.regions["tp_" + name]
print "#################################### ", name
print
print "==== SP layer ===="
print "input: ", SPRegion.getInputData(
"bottomUpIn").nonzero()[0][:20]
print "output: ", SPRegion.getOutputData(
"bottomUpOut").nonzero()[0][:20]
print
if self.tp_enable:
print "==== TP layer ===="
print "input: ", TPRegion.getInputData(
"bottomUpIn").nonzero()[0][:20]
print "output: ", TPRegion.getOutputData(
"bottomUpOut").nonzero()[0][:20]
print
print "==== Predict ===="
print TPRegion.getSelf()._tfdr.topDownCompute().copy().nonzero(
)[0][:20]
print
def save(self, path):
import pickle
with open(path, 'wb') as modelPickleFile:
pickle.dump(self, modelPickleFile)
def __init__(self,
numColumns,
L2Params,
L4Params,
L6aParams,
repeat,
logCalls=False):
"""
Create a network consisting of multiple columns. Each column contains one L2,
one L4 and one L6a layers. In addition all the L2 columns are fully
connected to each other through their lateral inputs.
:param numColumns: Number of columns to create
:type numColumns: int
:param L2Params: constructor parameters for :class:`ColumnPoolerRegion`
:type L2Params: dict
:param L4Params: constructor parameters for :class:`ApicalTMPairRegion`
:type L4Params: dict
:param L6aParams: constructor parameters for :class:`GridCellLocationRegion`
:type L6aParams: dict
:param repeat: Number of times each pair should be seen to be learned
:type repeat: int
:param logCalls: If true, calls to main functions will be logged internally.
The log can then be saved with saveLogs(). This allows us
to recreate the complete network behavior using
rerunExperimentFromLogfile which is very useful for
debugging.
:type logCalls: bool
"""
# Handle logging - this has to be done first
self.logCalls = logCalls
self.numColumns = numColumns
self.repeat = repeat
network = Network()
self.network = createMultipleL246aLocationColumn(
network=network,
numberOfColumns=self.numColumns,
L2Params=L2Params,
L4Params=L4Params,
L6aParams=L6aParams)
network.initialize()
self.sensorInput = []
self.motorInput = []
self.L2Regions = []
self.L4Regions = []
self.L6aRegions = []
for i in xrange(self.numColumns):
col = str(i)
self.sensorInput.append(network.regions["sensorInput_" +
col].getSelf())
self.motorInput.append(network.regions["motorInput_" +
col].getSelf())
self.L2Regions.append(network.regions["L2_" + col])
self.L4Regions.append(network.regions["L4_" + col])
self.L6aRegions.append(network.regions["L6a_" + col])
if L6aParams is not None and "dimensions" in L6aParams:
self.dimensions = L6aParams["dimensions"]
else:
self.dimensions = 2
self.sdrSize = L2Params["sdrSize"]
# will be populated during training
self.learnedObjects = {}
def testSimpleImageNetwork(self):
# Create the network and get region instances
net = Network()
net.addRegion("sensor", "py.ImageSensor", "{width: 32, height: 32}")
net.addRegion("classifier", "py.KNNClassifierRegion",
"{distThreshold: 0.01, maxCategoryCount: 2}")
net.link("sensor",
"classifier",
"UniformLink",
"",
srcOutput="dataOut",
destInput="bottomUpIn")
net.link("sensor",
"classifier",
"UniformLink",
"",
srcOutput="categoryOut",
destInput="categoryIn")
net.initialize()
sensor = net.regions['sensor']
classifier = net.regions['classifier']
# 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
sensor.executeCommand(["loadMultipleImages", tmpDir])
numImages = sensor.getParameter('numImages')
self.assertEqual(numImages, 2)
# Ensure learning is turned ON
self.assertEqual(classifier.getParameter('learningMode'), 1)
# Train the network (by default learning is ON in the classifier)
# and then turn off learning and turn on inference mode
net.run(2)
classifier.setParameter('inferenceMode', 1)
classifier.setParameter('learningMode', 0)
# Check to make sure learning is turned OFF and that the classifier learned
# something
self.assertEqual(classifier.getParameter('learningMode'), 0)
self.assertEqual(classifier.getParameter('inferenceMode'), 1)
self.assertEqual(classifier.getParameter('categoryCount'), 2)
self.assertEqual(classifier.getParameter('patternCount'), 2)
# Now test the network to make sure it categories the images correctly
numCorrect = 0
for i in range(2):
net.run(1)
inferredCategory = classifier.getOutputData(
'categoriesOut').argmax()
if sensor.getOutputData('categoryOut') == inferredCategory:
numCorrect += 1
self.assertEqual(numCorrect, 2)
# 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(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 reset(self, params, repetition):
"""
Take the steps necessary to reset the experiment before each repetition:
- Make sure random seed is different for each repetition
- Create the L2-L4-L6a network
- Generate objects used by the experiment
- Learn all objects used by the experiment
"""
print params["name"], ":", repetition
self.debug = params.get("debug", False)
L2Params = json.loads('{' + params["l2_params"] + '}')
L4Params = json.loads('{' + params["l4_params"] + '}')
L6aParams = json.loads('{' + params["l6a_params"] + '}')
# Make sure random seed is different for each repetition
seed = params.get("seed", 42)
np.random.seed(seed + repetition)
random.seed(seed + repetition)
L2Params["seed"] = seed + repetition
L4Params["seed"] = seed + repetition
L6aParams["seed"] = seed + repetition
# Configure L6a params
numModules = params["num_modules"]
L6aParams["scale"] = [params["scale"]] * numModules
angle = params["angle"] / numModules
orientation = range(angle / 2, angle * numModules, angle)
L6aParams["orientation"] = np.radians(orientation).tolist()
# Create multi-column L2-L4-L6a network
self.numColumns = params["num_cortical_columns"]
network = Network()
network = createMultipleL246aLocationColumn(network=network,
numberOfColumns=self.numColumns,
L2Params=L2Params,
L4Params=L4Params,
L6aParams=L6aParams)
network.initialize()
self.network = network
self.sensorInput = []
self.motorInput = []
self.L2Regions = []
self.L4Regions = []
self.L6aRegions = []
for i in xrange(self.numColumns):
col = str(i)
self.sensorInput.append(network.regions["sensorInput_" + col].getSelf())
self.motorInput.append(network.regions["motorInput_" + col].getSelf())
self.L2Regions.append(network.regions["L2_" + col])
self.L4Regions.append(network.regions["L4_" + col])
self.L6aRegions.append(network.regions["L6a_" + col])
# Use the number of iterations as the number of objects. This will allow us
# to execute one iteration per object and use the "iteration" parameter as
# the object index
numObjects = params["iterations"]
# Generate feature SDRs
numFeatures = params["num_features"]
numOfMinicolumns = L4Params["columnCount"]
numOfActiveMinicolumns = params["num_active_minicolumns"]
self.featureSDR = [{
str(f): sorted(np.random.choice(numOfMinicolumns, numOfActiveMinicolumns))
for f in xrange(numFeatures)
} for _ in xrange(self.numColumns)]
# Generate objects used in the experiment
self.objects = generateObjects(numObjects=numObjects,
featuresPerObject=params["features_per_object"],
objectWidth=params["object_width"],
numFeatures=numFeatures,
distribution=params["feature_distribution"])
# Make sure the objects are unique
uniqueObjs = np.unique([{"features": obj["features"]}
for obj in self.objects])
assert len(uniqueObjs) == len(self.objects)
self.sdrSize = L2Params["sdrSize"]
# Learn objects
self.numLearningPoints = params["num_learning_points"]
self.numOfSensations = params["num_sensations"]
self.learnedObjects = {}
self.learn()
def createNetwork(dataSource):
"""Create the Network instance.
:param dataSource: a RecordStream instance to get data from
:returns: a Network instance ready to run
"""
network = Network()
#----- SENSOR REGION -----#
# Input data comes from a CSV file (scalar values, labels). 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 = createScalarEncoder()
# Specify the dataSource as a file record stream instance
sensor.dataSource = dataSource
# Region width
prevRegionWidth = sensor.encoder.getWidth()
#----- SPATIAL POOLER -----#
# Create the spatial pooler region
SP_PARAMS["inputWidth"] = prevRegionWidth
network.addRegion("SP", "py.SPRegion", json.dumps(SP_PARAMS))
# Link the SP region to the sensor input
network.link("sensor", "SP", "UniformLink", "")
# Forward the sensor region sequence reset to the SP
network.link("sensor", "SP", "UniformLink", "", srcOutput="resetOut", destInput="resetIn")
# Make sure learning is ON
spatialPoolerRegion = network.regions["SP"]
spatialPoolerRegion.setParameter("learningMode", True)
# Inference mode outputs the current inference (e.g. active columns).
# It's ok to always leave inference mode on - it's only there for some corner cases.
spatialPoolerRegion.setParameter('inferenceMode', True)
# Region width
prevRegionWidth = SP_PARAMS['columnCount']
#----- TEMPORAL MEMORY -----#
# Make sure region widths fit
assert TM_PARAMS['columnCount'] == prevRegionWidth
TM_PARAMS['inputWidth'] = TM_PARAMS['columnCount']
# Create the TM region
network.addRegion("TM", "py.TPRegion", json.dumps(TM_PARAMS))
# Feed forward link from SP to TM
network.link("SP", "TM", "UniformLink", "", srcOutput="bottomUpOut", destInput="bottomUpIn")
# Feedback links (unnecessary ?)
network.link("TM", "SP", "UniformLink", "", srcOutput="topDownOut", destInput="topDownIn")
network.link("TM", "sensor", "UniformLink", "", srcOutput="topDownOut", destInput="temporalTopDownIn")
# Forward the sensor region sequence reset to the TM
network.link("sensor", "TM", "UniformLink", "", srcOutput="resetOut", destInput="resetIn")
# Make sure learning is enabled (this is the default)
temporalMemoryRegion = network.regions["TM"]
temporalMemoryRegion.setParameter("learningMode", False)
# Inference mode outputs the current inference (e.g. active cells).
# It's ok to always leave inference mode on - it's only there for some corner cases.
temporalMemoryRegion.setParameter('inferenceMode', True)
# Region width
prevRegionWidth = TM_PARAMS['inputWidth']
#----- CLASSIFIER REGION -----#
# create classifier region
network.addRegion('classifier', 'py.CLAClassifierRegion', json.dumps(CLA_CLASSIFIER_PARAMS))
# feed the TM states to the classifier
network.link("TM", "classifier", "UniformLink", "", srcOutput = "bottomUpOut", destInput = "bottomUpIn")
# create a link from the sensor to the classifier to send in category labels.
# TODO: this link is actually useless right now because the CLAclassifier region compute() function doesn't work
# and that we are feeding TM states & categories manually to the classifier via the customCompute() function.
network.link("sensor", "classifier", "UniformLink", "", srcOutput = "categoryOut", destInput = "categoryIn")
# disable learning for now (will be enables in a later training phase)
classifier = network.regions["classifier"]
classifier.setParameter('learningMode', False)
# Inference mode outputs the current inference. We can always leave it on.
classifier.setParameter('inferenceMode', True)
#------ INITIALIZE -----#
# The network until you try to run it. Make sure it's initialized right away.
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 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
# TODO: Needs TMRegion
network.addRegion("temporalMemoryRegion", "py.TPRegion",
json.dumps(TP_PARAMS))
network.link("spatialPoolerRegion", "temporalMemoryRegion", "UniformLink", "")
network.link("temporalMemoryRegion", "spatialPoolerRegion", "UniformLink", "",
srcOutput="topDownOut", destInput="topDownIn")
# Register TPRegion since we aren't in nupic
curDirectory = os.path.dirname(os.path.abspath(__file__))
# directory containing the union pooler directory is 2 directories above this file
unionTemporalPoolerDirectory = os.path.split((os.path.split(curDirectory))[0])[0]
sys.path.append(unionTemporalPoolerDirectory)
Network.registerRegionPackage("union_temporal_pooling")
# Add the TPRegion on top of the TPRegion
temporal = network.regions["temporalMemoryRegion"].getSelf()
UP_PARAMS["inputWidth"] = temporal.getOutputElementCount("bottomUpOut")
network.addRegion("unionTemporalPoolerRegion", "py.TemporalPoolerRegion", json.dumps(UP_PARAMS))
network.link("temporalMemoryRegion", "unionTemporalPoolerRegion", "UniformLink", "",
srcOutput="activeCells", destInput="activeCells")
network.link("temporalMemoryRegion", "unionTemporalPoolerRegion", "UniformLink", "",
srcOutput="predictedActiveCells", destInput="predictedActiveCells")
network.initialize()
spatial = network.regions["spatialPoolerRegion"].getSelf()
# Make sure learning is enabled (this is the default)
spatial.setParameter("learningMode", 1, True)
# We want temporal anomalies so disable anomalyMode in the SP. This mode is
# used for computing anomalies in a non-temporal model.
spatial.setParameter("anomalyMode", 1, False)
# Enable topDownMode to get the predicted columns output
temporal.setParameter("topDownMode", 1, True)
# Make sure learning is enabled (this is the default)
temporal.setParameter("learningMode", 1, True)
# Enable inference mode so we get predictions
temporal.setParameter("inferenceMode", 1, True)
temporal.setParameter("computePredictedActiveCellIndices", 1, True)
union = network.regions["unionTemporalPoolerRegion"].getSelf()
# Make sure learning is enabled (this is the default)
union.setParameter("learningMode", 1, True)
return network
def testCreateL4L6aLocationColumn(self):
"""
Test 'createL4L6aLocationColumn' by inferring a set of hand crafted objects
"""
scale = []
orientation = []
# Initialize L6a location region with 5 modules varying scale by sqrt(2) and
# 4 different random orientations for each scale
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))
net = Network()
createL4L6aLocationColumn(
net, {
"inverseReadoutResolution": 8,
"sensorInputSize": NUM_OF_CELLS,
"L4Params": {
"columnCount": NUM_OF_COLUMNS,
"cellsPerColumn": CELLS_PER_COLUMN,
"activationThreshold": 15,
"minThreshold": 15,
"initialPermanence": 1.0,
"implementation": "ApicalTiebreak",
"maxSynapsesPerSegment": -1
},
"L6aParams": {
"moduleCount": len(scale),
"scale": scale,
"orientation": orientation,
"anchorInputSize": NUM_OF_CELLS,
"activationThreshold": 8,
"initialPermanence": 1.0,
"connectedPermanence": 0.5,
"learningThreshold": 8,
"sampleSize": 10,
"permanenceIncrement": 0.1,
"permanenceDecrement": 0.0,
"bumpOverlapMethod": "probabilistic"
}
})
net.initialize()
L4 = net.regions['L4']
L6a = net.regions['L6a']
sensor = net.regions['sensorInput'].getSelf()
motor = net.regions['motorInput'].getSelf()
# Keeps a list of learned objects
learnedRepresentations = defaultdict(list)
# Learn Objects
self._setLearning(net, True)
for objectDescription in OBJECTS:
reset = True
previousLocation = None
L6a.executeCommand(["activateRandomLocation"])
for iFeature, feature in enumerate(objectDescription["features"]):
# Move the sensor to the center of the object
locationOnObject = np.array([
feature["top"] + feature["height"] / 2.,
feature["left"] + feature["width"] / 2.
])
# Calculate displacement from previous location
if previousLocation is not None:
motor.addDataToQueue(locationOnObject - previousLocation)
previousLocation = locationOnObject
# Sense feature at location
sensor.addDataToQueue(FEATURE_ACTIVE_COLUMNS[feature["name"]],
reset, 0)
net.run(1)
reset = False
# Save learned representations
representation = L6a.getOutputData("sensoryAssociatedCells")
representation = representation.nonzero()[0]
learnedRepresentations[(objectDescription["name"],
iFeature)] = representation
# Infer objects
self._setLearning(net, False)
for objectDescription in OBJECTS:
reset = True
previousLocation = None
inferred = False
features = objectDescription["features"]
touchSequence = range(len(features))
random.shuffle(touchSequence)
for iFeature in touchSequence:
feature = features[iFeature]
# Move the sensor to the center of the object
locationOnObject = np.array([
feature["top"] + feature["height"] / 2.,
feature["left"] + feature["width"] / 2.
])
# Calculate displacement from previous location
if previousLocation is not None:
motor.addDataToQueue(locationOnObject - previousLocation)
previousLocation = locationOnObject
# Sense feature at location
sensor.addDataToQueue(FEATURE_ACTIVE_COLUMNS[feature["name"]],
reset, 0)
net.run(1)
reset = False
representation = L6a.getOutputData("sensoryAssociatedCells")
representation = representation.nonzero()[0]
target_representations = set(
learnedRepresentations[(objectDescription["name"],
iFeature)])
inferred = (set(representation) <= target_representations)
if inferred:
break
self.assertTrue(inferred)
def testSimpleImageNetwork(self):
# Create the network and get region instances
net = Network()
net.addRegion("sensor", "py.ImageSensor", "{width: 32, height: 32}")
net.addRegion("classifier","py.KNNClassifierRegion",
"{distThreshold: 0.01, maxCategoryCount: 2}")
net.link("sensor", "classifier", "UniformLink", "",
srcOutput = "dataOut", destInput = "bottomUpIn")
net.link("sensor", "classifier", "UniformLink", "",
srcOutput = "categoryOut", destInput = "categoryIn")
net.initialize()
sensor = net.regions['sensor']
classifier = net.regions['classifier']
# 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
sensor.executeCommand(["loadMultipleImages", tmpDir])
numImages = sensor.getParameter('numImages')
self.assertEqual(numImages, 2)
# Ensure learning is turned ON
self.assertEqual(classifier.getParameter('learningMode'), 1)
# Train the network (by default learning is ON in the classifier)
# and then turn off learning and turn on inference mode
net.run(2)
classifier.setParameter('inferenceMode', 1)
classifier.setParameter('learningMode', 0)
# Check to make sure learning is turned OFF and that the classifier learned
# something
self.assertEqual(classifier.getParameter('learningMode'), 0)
self.assertEqual(classifier.getParameter('inferenceMode'), 1)
self.assertEqual(classifier.getParameter('categoryCount'),2)
self.assertEqual(classifier.getParameter('patternCount'),2)
# Now test the network to make sure it categories the images correctly
numCorrect = 0
for i in range(2):
net.run(1)
inferredCategory = classifier.getOutputData('categoriesOut').argmax()
if sensor.getOutputData('categoryOut') == inferredCategory:
numCorrect += 1
self.assertEqual(numCorrect,2)
# 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'))
class ClaClassifier():
def __init__(self, net_structure, sensor_params, dest_region_params, class_encoder_params):
self.run_number = 0
# for classifier
self.classifier_encoder_list = {}
self.classifier_input_list = {}
self.prevPredictedColumns = {}
# TODO: 消したいパラメータ
self.predict_value = class_encoder_params.keys()[0]
self.predict_step = 0
# default param
self.default_params = {
'SP_PARAMS': {
"spVerbosity": 0,
"spatialImp": "cpp",
"globalInhibition": 1,
"columnCount": 2024,
"inputWidth": 0, # set later
"numActiveColumnsPerInhArea": 20,
"seed": 1956,
"potentialPct": 0.8,
"synPermConnected": 0.1,
"synPermActiveInc": 0.05,
"synPermInactiveDec": 0.0005,
"maxBoost": 2.0,
},
'TP_PARAMS': {
"verbosity": 0,
"columnCount": 2024,
"cellsPerColumn": 32,
"inputWidth": 2024,
"seed": 1960,
"temporalImp": "cpp",
"newSynapseCount": 20,
"maxSynapsesPerSegment": 32,
"maxSegmentsPerCell": 128,
"initialPerm": 0.21,
"permanenceInc": 0.2,
"permanenceDec": 0.1,
"globalDecay": 0.0,
"maxAge": 0,
"minThreshold": 12,
"activationThreshold": 16,
"outputType": "normal",
"pamLength": 1,
},
'CLASSIFIER_PARAMS': {
"clVerbosity": 0,
"alpha": 0.005,
"steps": "0"
}
}
# tp
self.tp_enable = True
# net structure
self.net_structure = OrderedDict()
self.net_structure['sensor3'] = ['region1']
self.net_structure['region1'] = ['region2']
self.net_structure = net_structure
# region change params
self.dest_region_params = dest_region_params
# sensor change params
self.sensor_params = sensor_params
self.class_encoder_params = class_encoder_params
self._createNetwork()
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 _linkRegion(self, src_name, dest_name):
sensor = src_name
sp_name = "sp_" + dest_name
tp_name = "tp_" + dest_name
class_name = "class_" + dest_name
if self.tp_enable:
self.network.link(sensor, sp_name, "UniformLink", "")
self.network.link(sp_name, tp_name, "UniformLink", "")
self.network.link(tp_name, class_name, "UniformLink", "")
else:
self.network.link(sensor, sp_name, "UniformLink", "")
self.network.link(sp_name, class_name, "UniformLink", "")
def _initRegion(self, name):
sp_name = "sp_"+ name
tp_name = "tp_"+ name
class_name = "class_"+ name
# setting sp
SP = self.network.regions[sp_name]
SP.setParameter("learningMode", True)
SP.setParameter("anomalyMode", True)
# # setting tp
if self.tp_enable:
TP = self.network.regions[tp_name]
TP.setParameter("topDownMode", False)
TP.setParameter("learningMode", True)
TP.setParameter("inferenceMode", True)
TP.setParameter("anomalyMode", False)
# classifier regionを定義.
classifier = self.network.regions[class_name]
classifier.setParameter('inferenceMode', True)
classifier.setParameter('learningMode', True)
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
#@profile
def run(self, input_data, learn=True, class_learn=True,learn_layer=None):
"""
networkの実行.
学習したいときは, learn=True, ftypeを指定する.
予測したいときは, learn=False, ftypeはNoneを指定する.
学習しているときも, 予測はしているがな.
input_data = {'xy_value': [1.0, 2.0], 'ftype': 'sin'}
"""
self.enable_learning_mode(learn, learn_layer)
self.enable_class_learning_mode(class_learn)
self.run_number += 1
# calc encoder, SP, TP
for sensor_name in self.sensor_params.keys():
self.network.regions[sensor_name].getSelf().dataSource.push(input_data)
self.network.run(1)
#self.layer_output(input_data)
#self.debug(input_data)
# learn classifier
inferences = {}
for name in self.dest_region_params.keys():
class_name = "class_" + name
inferences['classifier_'+name] = self._learn_classifier_multi(class_name, actValue=input_data[self.predict_value], pstep=self.predict_step)
# anomaly
#inferences["anomaly"] = self._calc_anomaly()
return inferences
def _learn_classifier_multi(self, region_name, actValue=None, pstep=0):
"""
classifierの計算を行う.
直接customComputeを呼び出さずに, network.runの中でやりたいところだけど,
計算した内容の取り出し方法がわからない.
"""
# TODO: networkとclassifierを完全に切り分けたいな.
# networkでは, sensor,sp,tpまで計算を行う.
# その計算結果の評価/利用は外に出す.
classifier = self.network.regions[region_name]
encoder = self.classifier_encoder_list[region_name].getEncoderList()[0]
class_input = self.classifier_input_list[region_name]
tp_bottomUpOut = self.network.regions[class_input].getOutputData("bottomUpOut").nonzero()[0]
#tp_bottomUpOut = self.network.regions["TP"].getSelf()._tfdr.infActiveState['t'].reshape(-1).nonzero()[0]
if actValue is not None:
bucketIdx = encoder.getBucketIndices(actValue)[0]
classificationIn = {
'bucketIdx': bucketIdx,
'actValue': actValue
}
else:
classificationIn = {'bucketIdx': 0,'actValue': 'no'}
clResults = classifier.getSelf().customCompute(
recordNum=self.run_number,
patternNZ=tp_bottomUpOut,
classification=classificationIn
)
inferences= self._get_inferences(clResults, pstep, summary_tyep='sum')
return inferences
def _get_inferences(self, clResults, steps, summary_tyep='sum'):
"""
classifierの計算結果を使いやすいように変更するだけ.
"""
likelihoodsVec = clResults[steps]
bucketValues = clResults['actualValues']
likelihoodsDict = defaultdict(int)
bestActValue = None
bestProb = None
if summary_tyep == 'sum':
for (actValue, prob) in zip(bucketValues, likelihoodsVec):
likelihoodsDict[actValue] += prob
if bestProb is None or likelihoodsDict[actValue] > bestProb:
bestProb = likelihoodsDict[actValue]
bestActValue = actValue
elif summary_tyep == 'best':
for (actValue, prob) in zip(bucketValues, likelihoodsVec):
if bestProb is None or prob > bestProb:
likelihoodsDict[actValue] = prob
bestProb = prob
bestActValue = actValue
return {'likelihoodsDict': likelihoodsDict, 'best': {'value': bestActValue, 'prob':bestProb}}
def _calc_anomaly(self):
"""
各層のanomalyを計算
"""
score = 0
anomalyScore = {}
for name in self.dest_region_params.keys():
#sp_bottomUpOut = self.network.regions["sp_"+name].getOutputData("bottomUpOut").nonzero()[0]
sp_bottomUpOut = self.network.regions["tp_"+name].getInputData("bottomUpIn").nonzero()[0]
if self.prevPredictedColumns.has_key(name):
score = computeAnomalyScore(sp_bottomUpOut, self.prevPredictedColumns[name])
#topdown_predict = self.network.regions["TP"].getSelf()._tfdr.topDownCompute().copy().nonzero()[0]
topdown_predict = self.network.regions["tp_"+name].getSelf()._tfdr.topDownCompute().nonzero()[0]
self.prevPredictedColumns[name] = copy.deepcopy(topdown_predict)
anomalyScore[name] = score
return anomalyScore
def reset(self):
"""
reset sequence
"""
# for name in self.dest_region_params.keys():
# self.network.regions["tp_"+name].getSelf().resetSequenceStates()
return
# for sensor_name in self.sensor_params.keys():
# sensor = self.network.regions[sensor_name].getSelf()
# sensor.dataSource = DataBuffer()
def enable_class_learning_mode(self, enable):
for name in self.dest_region_params.keys():
self.network.regions["class_"+name].setParameter("learningMode", enable)
def enable_learning_mode(self, enable, layer_name = None):
"""
各層のSP, TP, ClassifierのlearningModeを変更
"""
if layer_name is None:
for name in self.dest_region_params.keys():
self.network.regions["sp_"+name].setParameter("learningMode", enable)
if self.tp_enable:
self.network.regions["tp_"+name].setParameter("learningMode", enable)
self.network.regions["class_"+name].setParameter("learningMode", enable)
else:
for name in self.dest_region_params.keys():
self.network.regions["sp_"+name].setParameter("learningMode", not enable)
if self.tp_enable:
self.network.regions["tp_"+name].setParameter("learningMode", not enable)
self.network.regions["class_"+name].setParameter("learningMode", not enable)
for name in layer_name:
self.network.regions["sp_"+name].setParameter("learningMode", enable)
if self.tp_enable:
self.network.regions["tp_"+name].setParameter("learningMode", enable)
self.network.regions["class_"+name].setParameter("learningMode", enable)
def print_inferences(self, input_data, inferences):
"""
計算結果を出力する
"""
# print "%10s, %10s, %1s" % (
# int(input_data['xy_value'][0]),
# int(input_data['xy_value'][1]),
# input_data['label'][:1]),
print "%5s" % (
input_data['label']),
try:
for name in sorted(self.dest_region_params.keys()):
print "%5s" % (inferences['classifier_'+name]['best']['value']),
for name in sorted(self.dest_region_params.keys()):
print "%6.4f," % (inferences['classifier_'+name]['likelihoodsDict'][input_data[self.predict_value]]),
except:
pass
# for name in sorted(self.dest_region_params.keys()):
# print "%3.2f," % (inferences["anomaly"][name]),
# for name in sorted(self.dest_region_params.keys()):
# print "%5s," % name,
print
def layer_output(self, input_data, region_name=None):
if region_name is not None:
Region = self.network.regions[region_name]
print Region.getOutputData("bottomUpOut").nonzero()[0]
return
for name in self.dest_region_params.keys():
SPRegion = self.network.regions["sp_"+name]
if self.tp_enable:
TPRegion = self.network.regions["tp_"+name]
print "#################################### ", name
print
print "==== SP layer ===="
print "input: ", SPRegion.getInputData("bottomUpIn").nonzero()[0][:20]
print "output: ", SPRegion.getOutputData("bottomUpOut").nonzero()[0][:20]
print
if self.tp_enable:
print "==== TP layer ===="
print "input: ", TPRegion.getInputData("bottomUpIn").nonzero()[0][:20]
print "output: ", TPRegion.getOutputData("bottomUpOut").nonzero()[0][:20]
print
print "==== Predict ===="
print TPRegion.getSelf()._tfdr.topDownCompute().copy().nonzero()[0][:20]
print
def save(self, path):
import pickle
with open(path, 'wb') as modelPickleFile:
pickle.dump(self, modelPickleFile)
class HTM():
def __init__(self, dataSource, rdse_resolution, params=None, verbosity=3):
"""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 TMRegion.
:param dataSource: a RecordStream instance to get data from
:param rdse_resolution: float, resolution of Random Distributed Scalar Encoder
:param cellsPerMiniColumn: int, number of cells per mini-column. Default=32
"""
DATE = '{}'.format(strftime('%Y-%m-%d_%H:%M:%S', localtime()))
self.log_file = join(
'../logs/', 'HTM-{}-({}RDSEres)-datasource-{}.log'.format(
DATE, rdse_resolution, str(dataSource)))
log.basicConfig(format='[%(asctime)s] %(message)s',
datefmt='%m/%d/%Y %H:%M:%S %p',
filename=self.log_file,
level=log.DEBUG)
self.streaming = False
self.setVerbosity(verbosity)
self.modelParams = {}
log.debug("...loading params from {}...".format(_PARAMS_PATH))
try:
with open(_PARAMS_PATH, "r") as f:
self.modelParams = yaml.safe_load(f)["modelParams"]
except:
with open(os.path.join("..", _PARAMS_PATH), "r") as f:
self.modelParams = yaml.safe_load(f)["modelParams"]
# Create a network that will hold the regions.
self.network = Network()
# Add a sensor region.
self.network.addRegion("sensor", "py.RecordSensor", '{}')
# Set the encoder and data source of the sensor region.
self.sensorRegion = self.network.regions["sensor"].getSelf()
#sensorRegion.encoder = createEncoder(modelParams["sensorParams"]["encoders"])
self.encoder = RDSEEncoder(rdse_resolution)
self.sensorRegion.encoder = self.encoder.get_encoder()
self.sensorRegion.dataSource = TimeSeriesStream(dataSource)
self.network.regions["sensor"].setParameter("predictedField", "series")
# Adjust params
# Make sure the SP input width matches the sensor region output width.
self.modelParams["spParams"][
"inputWidth"] = self.sensorRegion.encoder.getWidth()
if not params == None:
for key, value in params.iteritems():
if key == "clParams" or key == "spParams" or key == "tmParams":
for vkey, vvalue in value.iteritems():
#print(key, vkey, vvalue)
self.modelParams[key][vkey] = vvalue
log.debug("xxx HTM Params: xxx\n{}\n".format(
json.dumps(self.modelParams, sort_keys=True, indent=4)))
# Add SP and TM regions.
self.network.addRegion("spatialPoolerRegion", "py.SPRegion",
json.dumps(self.modelParams["spParams"]))
self.network.addRegion("temporalPoolerRegion", "py.TMRegion",
json.dumps(self.modelParams["tmParams"]))
# Add a classifier region.
clName = "py.%s" % self.modelParams["clParams"].pop("regionName")
self.network.addRegion("classifier", clName,
json.dumps(self.modelParams["clParams"]))
# link regions
self.linkSensorToClassifier()
self.linkSensorToSpatialPooler()
self.linkSpatialPoolerToTemporalPooler()
self.linkTemporalPoolerToClassifier()
self.linkResets()
# possibly do reset links here (says they are optional
self.network.initialize()
self.turnInferenceOn()
self.turnLearningOn()
def __del__(self):
""" closes all loggers """
try:
logger = log.getLogger()
handlers = logger.handlers[:]
for handler in handlers:
try:
handler.close()
logger.removeHandler(handler)
except:
pass
except:
pass
def __str__(self):
spRegion = self.network.getRegionsByType(SPRegion)[0]
sp = spRegion.getSelf().getAlgorithmInstance()
_str = "spatial pooler region inputs: {0}\n".format(
spRegion.getInputNames())
_str += "spatial pooler region outputs: {0}\n".format(
spRegion.getOutputNames())
_str += "# spatial pooler columns: {0}\n\n".format(sp.getNumColumns())
tmRegion = self.network.getRegionsByType(TMRegion)[0]
tm = tmRegion.getSelf().getAlgorithmInstance()
_str += "temporal memory region inputs: {0}\n".format(
tmRegion.getInputNames())
_str += "temporal memory region outputs: {0}\n".format(
tmRegion.getOutputNames())
_str += "# temporal memory columns: {0}\n".format(tm.numberOfCols)
return _str
def getClassifierResults(self):
"""Helper function to extract results for all prediction steps."""
classifierRegion = self.network.regions["classifier"]
actualValues = classifierRegion.getOutputData("actualValues")
probabilities = classifierRegion.getOutputData("probabilities")
steps = classifierRegion.getSelf().stepsList
N = classifierRegion.getSelf().maxCategoryCount
results = {step: {} for step in steps}
for i in range(len(steps)):
# stepProbabilities are probabilities for this prediction step only.
stepProbabilities = probabilities[i * N:(i + 1) * N - 1]
mostLikelyCategoryIdx = stepProbabilities.argmax()
predictedValue = actualValues[mostLikelyCategoryIdx]
predictionConfidence = stepProbabilities[mostLikelyCategoryIdx]
results[steps[i]]["predictedValue"] = float(predictedValue)
results[steps[i]]["predictionConfidence"] = float(
predictionConfidence)
log.debug("Classifier Reults:\n{}".format(
json.dumps(results, sort_keys=True, indent=4)))
return results
def getCurrSeries(self):
return self.network.regions["sensor"].getOutputData("sourceOut")[0]
def getStepsList(self):
return self.network.regions["classifier"].getSelf().stepsList
def getTimeSeriesStream(self):
return self.network.regions["sensor"].getSelf().dataSource
def setDatasource(self, new_source):
self.network.regions["sensor"].getSelf().dataSource = TimeSeriesStream(
new_source)
def linkResets(self):
"""createResetLink(network, "sensor", "spatialPoolerRegion")
createResetLink(network, "sensor", "temporalPoolerRegion")"""
self.network.link("sensor",
"spatialPoolerRegion",
"UniformLink",
"",
srcOutput="resetOut",
destInput="resetIn")
self.network.link("sensor",
"temporalPoolerRegion",
"UniformLink",
"",
srcOutput="resetOut",
destInput="resetIn")
def linkSensorToClassifier(self):
"""Create required links from a sensor region to a classifier region."""
self.network.link("sensor",
"classifier",
"UniformLink",
"",
srcOutput="bucketIdxOut",
destInput="bucketIdxIn")
self.network.link("sensor",
"classifier",
"UniformLink",
"",
srcOutput="actValueOut",
destInput="actValueIn")
self.network.link("sensor",
"classifier",
"UniformLink",
"",
srcOutput="categoryOut",
destInput="categoryIn")
def linkSensorToSpatialPooler(self):
self.network.link("sensor",
"spatialPoolerRegion",
"UniformLink",
"",
srcOutput="dataOut",
destInput="bottomUpIn")
def linkSpatialPoolerToTemporalPooler(self):
"""Create a feed-forward link between 2 regions: spatialPoolerRegion -> temporalPoolerRegion"""
self.network.link("spatialPoolerRegion",
"temporalPoolerRegion",
"UniformLink",
"",
srcOutput="bottomUpOut",
destInput="bottomUpIn")
def linkTemporalPoolerToClassifier(self):
"""Create a feed-forward link between 2 regions: temporalPoolerRegion -> classifier"""
self.network.link("temporalPoolerRegion",
"classifier",
"UniformLink",
"",
srcOutput="bottomUpOut",
destInput="bottomUpIn")
def setVerbosity(self, level):
"""
Sets the level of print statements/logging (verbosity)
* 3 == DEBUG
* 2 == VERBOSE
* 1 == WARNING
"""
if self.log_file == None: # if there's no log file, make one
DATE = '{}'.format(strftime('%Y-%m-%d_%H:%M:%S', localtime()))
self.log_file = join(
'../logs/',
'HTM-{}-({}CPMC-{}RDSEres)-datasource-{}.log'.format(
DATE, self.modelParams["tmParams"]["cellsPerColumn"],
self.encoder.get_resolution(),
str(self.sensorRegion.dataSource)))
log.basicConfig(format='[%(asctime)s] %(message)s',
datefmt='%m/%d/%Y %H:%M:%S %p',
filename=self.log_file,
level=log.DEBUG)
if level >= 4 and not self.streaming:
log.getLogger().addHandler(log.StreamHandler())
self.streaming = True
if level >= 3:
log.getLogger().setLevel(log.DEBUG)
elif level >= 2:
log.getLogger().setLevel(log.VERBOSE)
elif level >= 1:
log.getLogger().setLevel(log.WARNING)
def runNetwork(self, learning=True):
DATE = '{}'.format(strftime('%Y-%m-%d_%H:%M:%S', localtime()))
_OUTPUT_PATH = "../outputs/HTMOutput-{}-{}.csv".format(
DATE, self.network.regions["sensor"].getSelf().dataSource)
self.sensorRegion.dataSource.rewind()
# Set predicted field
self.network.regions["sensor"].setParameter("predictedField", "series")
if learning == True:
# Enable learning for all regions.
self.turnLearningOn()
elif learning == False:
# Enable learning for all regions.
self.turnLearningOff()
else:
self.turnLearningOff()
self.turnLearningOn(learning)
self.turnInferenceOn()
_model = self.network.regions["sensor"].getSelf().dataSource
with open(_OUTPUT_PATH, "w") as outputFile:
writer = csv.writer(outputFile)
log.info("Writing output to {}".format(_OUTPUT_PATH))
steps = self.getStepsList()
header_row = ["Time Step", "Series"]
for step in steps:
header_row.append("{} Step Pred".format(step))
header_row.append("{} Step Pred Conf".format(step))
writer.writerow(header_row)
results = []
one_preds = []
for i in range(len(_model)):
# Run the network for a single iteration
self.network.run(1)
series = self.network.regions["sensor"].getOutputData(
"sourceOut")[0]
predictionResults = self.getClassifierResults()
result = [_model.getBookmark(), series]
one_preds.append(predictionResults[1]["predictedValue"])
for key, value in predictionResults.iteritems():
result.append(value["predictedValue"])
result.append(value["predictionConfidence"] * 100)
#print "{:6}: 1-step: {:16} ({:4.4}%)\t 5-step: {:16} ({:4.4}%)".format(*result)
results.append(result)
writer.writerow(result)
outputFile.flush()
return one_preds, results
def runWithMode(self,
mode,
error_method="rmse",
weights={
1: 1.0,
5: 1.0
},
normalize_error=False):
'''
Modes:
* "strain" - Learning on spatial pool, on training set
* "train" - Learning, on training set
* "test" - No learning, on test set
* "eval" - Learning, on eval set
'''
mode = mode.lower()
error_method = error_method.lower()
log.debug(
"entered `runWithMode` with with:\n mode: {}\n error_method: {}"
.format(mode, error_method))
_model = self.getTimeSeriesStream()
if mode == "strain":
self.turnLearningOff("ct")
self.turnLearningOn("s")
else:
self.turnLearningOn()
self.turnInferenceOn()
results = {}
steps = self.getStepsList()
for step in steps:
results[step] = 0
predictions = {}
for step in steps:
predictions[step] = [None] * step
last_prediction = None
five_pred = [None] * 5 # list of 5 Nones
if mode == "strain" or mode == "train":
_model.set_to_train_theta()
while _model.in_train_set():
temp = self.run_with_mode_one_iter(error_method, results,
predictions)
results = temp[0]
predictions = temp[1]
elif mode == "test":
_model.set_to_test_theta()
while _model.in_test_set():
temp = self.run_with_mode_one_iter(error_method, results,
predictions)
results = temp[0]
predictions = temp[1]
elif mode == "eval":
_model.set_to_eval_theta()
while _model.in_eval_set():
temp = self.run_with_mode_one_iter(error_method, results,
predictions)
results = temp[0]
predictions = temp[1]
steps = self.getStepsList()
for step in steps:
weights[step] = 0
weights[
1] = 1 # weights for eval hard-coded to just look at one-step prediction for now
# normalize result over length of evaluation set
for key in results:
results[key] /= (self.sensorRegion.dataSource.len_eval_set() -
1)
# preprocess weights to put in zero weights
for key, value in results.iteritems():
try:
weights[key]
except:
weights[key] = 0
for key, value in results.iteritems():
results[key] = results[key] * weights[key]
if normalize_error == True:
_range = self.getTimeSeriesStream().get_range()
if not _range == None:
for key, value in results.iteritems():
results[key] = value / _range
return results
def run_with_mode_one_iter(self, error_method, results, predictions=None):
self.network.run(1)
series = self.getCurrSeries()
for key, value in results.iteritems():
if predictions[key][0] == None:
pass
elif error_method == "rmse":
results[key] += sqrt((series - predictions[key][0])**2)
elif error_method == "binary":
if not series == predictions[key][0]:
results[key] += 1
# update predictions
classRes = self.getClassifierResults()
for key, value in predictions.iteritems():
for i in range(key - 1):
value[i] = value[i + 1] # shift predictions down one
value[key - 1] = classRes[key]["predictedValue"]
return (results, predictions)
def setRDSEResolution(self, new_res):
self.encoder = RDSEEncoder(new_res)
def train(self,
error_method="rmse",
sibt=0,
iter_per_cycle=1,
max_cycles=20,
weights={
1: 1.0,
5: 1.0
},
normalize_error=False):
"""
Trains the HTM on `dataSource`
:param error_method - the metric for calculating error ("rmse" root mean squared error or "binary")
:param sibt - spatial (pooler) iterations before temporal (pooler)
"""
for i in range(sibt):
log.debug(
"\nxxxxx Iteration {}/{} of the Spatial Pooler Training xxxxx".
format(i + 1, sibt))
# train on spatial pooler
log.debug(
"Error for spatial training iteration {} was {} with {} error method"
.format(
i,
self.runWithMode("strain", error_method, weights,
normalize_error), error_method))
log.info("\nExited spatial pooler only training loop")
last_error = 0 # set to infinity error so you keep training the first time
curr_error = -1
counter = 0
log.info("Entering full training loop")
while (fcompare(curr_error, last_error) == -1
and counter < max_cycles):
log.debug(
"\n++++++++++ Cycle {} of the full training loop +++++++++\n".
format(counter))
last_error = curr_error
curr_error = 0
for i in range(int(iter_per_cycle)):
log.debug("\n----- Iteration {}/{} of Cycle {} -----\n".format(
i + 1, iter_per_cycle, counter))
log.debug(
"Error for full training cycle {}, iteration {} was {} with {} error method"
.format(
counter, i,
self.runWithMode("train", error_method, weights,
normalize_error), error_method))
result = self.runWithMode("test", error_method, weights,
normalize_error)
for key, value in result.iteritems():
curr_error += value
log.debug("Cycle {} - last: {} curr: {}".format(
counter, last_error, curr_error))
counter += 1
if last_error == -1:
last_error = float("inf")
self.sensorRegion.dataSource.rewind()
final_error = self.runWithMode("eval", error_method, weights,
normalize_error)
log.info("FINAL ERROR: {}".format(final_error[1]))
return final_error[1]
def turnInferenceOn(self):
log.debug("Inference enabled for all regions")
self.network.regions["spatialPoolerRegion"].setParameter(
"inferenceMode", 1)
self.network.regions["temporalPoolerRegion"].setParameter(
"inferenceMode", 1)
self.network.regions["classifier"].setParameter("inferenceMode", 1)
def turnLearningOn(self, turnOn="cst"):
"""
Turns learning on for certain segments
:param turnOn - a string of characters representing the segments you'd like to turn on
* c ---> classifier
* s ---> spatial pooler
* t ---> temporal pooler
"""
for i in range(len(turnOn)):
target = turnOn[0].lower()
turnOn = turnOn[1:]
if target == "c":
log.debug("Learning enabled for classifier")
self.network.regions["classifier"].setParameter(
"learningMode", 1)
elif target == "s":
log.debug("Learning enabled for spatial pooler region")
self.network.regions["spatialPoolerRegion"].setParameter(
"learningMode", 1)
elif target == "t":
log.debug("Learning enabled for temporal pooler region")
self.network.regions["temporalPoolerRegion"].setParameter(
"learningMode", 1)
def turnLearningOff(self, turnOff="cst"):
"""
Turns learning off for certain segments
:param turnOff - a string of characters representing the segments you'd like to turn off
* c ---> classifier
* s ---> spatial pooler
* t ---> temporal pooler
"""
for i in range(len(turnOff)):
target = turnOff[0].lower()
turnOff = turnOff[1:]
if target == "c":
log.debug("Learning disabled for classifier")
self.network.regions["classifier"].setParameter(
"learningMode", 0)
elif target == "s":
log.debug("Learning disabled for spatial pooler region")
self.network.regions["spatialPoolerRegion"].setParameter(
"learningMode", 0)
elif target == "t":
log.debug("Learning disabled for temporal pooler region")
self.network.regions["temporalPoolerRegion"].setParameter(
"learningMode", 0)
