def __init__(self,
motorValues=range(-4, 4 + 1),
sparsity=0.02,
encoderResolution=1.0,
tmParams=None):
super(PositionPredictionModel, self).__init__(motorValues=motorValues)
tmParams = tmParams or {}
self.tm = MonitoredGeneralTemporalMemory(mmName="TM", **tmParams)
self.n = self.tm.numberOfColumns()
self.w = int(self.n * sparsity) + 1
self.encoderResolution = encoderResolution
self.sensorEncoder = CoordinateEncoder(w=self.w, n=self.n)
self.motorEncoder = CoordinateEncoder(w=self.w, n=self.n)
def overlapsForRelativeAreas(n,
w,
initPosition,
initRadius,
dPosition=None,
dRadius=0,
num=100,
verbose=False):
"""
Return overlaps between an encoding and other encodings relative to it
"""
encoder = CoordinateEncoder(name="coordinate", n=n, w=w)
overlaps = np.empty(num)
outputA = encode(encoder, np.array(initPosition), initRadius)
for i in range(num):
newPosition = initPosition if dPosition == None else (
initPosition + (i + 1) * dPosition)
newRadius = initRadius + (i + 1) * dRadius
outputB = encode(encoder, newPosition, newRadius)
overlaps[i] = overlap(outputA, outputB)
if verbose:
print
print(
"===== Relative encoding overlaps (n = {0}, w = {1}, "
"initPosition = {2}, initRadius = {3}, "
"dPosition = {4}, dRadius = {5}) =====").format(
n, w, initPosition, initRadius, dPosition, dRadius)
print "Average: {0}".format(np.average(overlaps))
print "Max: {0}".format(np.max(overlaps))
return overlaps
def createLocationEncoder(t, w=15):
"""
A default coordinate encoder for encoding locations into sparse
distributed representations.
"""
encoder = CoordinateEncoder(name="positionEncoder", n=t.l6CellCount, w=w)
return encoder
def __init__(self,
motorValues=range(-4, 4 + 1),
sparsity=0.02,
encoderResolution=1.0,
tmParams=None):
super(PositionPredictionModel, self).__init__(motorValues=motorValues)
tmParams = dict(DEFAULT_TM_PARAMS)
tmParams.update(tmParams or {})
self.tm = MonitoredApicalTiebreakPairMemory(mmName="TM", **tmParams)
self.n = self.tm.numberOfColumns()
self.w = int(self.n * sparsity) + 1
self.encoderResolution = encoderResolution
self.sensorEncoder = CoordinateEncoder(w=self.w, n=self.n)
self.motorEncoder = CoordinateEncoder(w=self.w, n=self.n)
self.prevMotorPattern = ()
def testEncodeSaturateArea(self):
n = 1999
w = 25
encoder = CoordinateEncoder(name="coordinate", n=n, w=w)
outputA = encode(encoder, np.array([0, 0]), 2)
outputB = encode(encoder, np.array([0, 1]), 2)
self.assertEqual(overlap(outputA, outputB), 0.8)
def __init__(self, activeBits=21, outputWidth=1000, radius=2, verbosity=0):
self.verbosity = verbosity
self.activeBits = activeBits
self.outputWidth = outputWidth
self.radius = radius
self.queue = deque()
self.encoder = CoordinateEncoder(n=self.outputWidth,
w=self.activeBits,
verbosity=self.verbosity)
def run():
n = 999
w = 25
encoder = CoordinateEncoder(name='coordinate', n=n, w=w)
Patcher().patchCoordinateEncoder(encoder, encoder.name)
encode(encoder, numpy.array([-149, 24]), 3)
encode(encoder, numpy.array([-148, 24]), 3)
encode(encoder, numpy.array([-147, 24]), 3)
encode(encoder, numpy.array([-146, 24]), 3)
encode(encoder, numpy.array([-145, 24]), 3)
encode(encoder, numpy.array([-144, 24]), 3)
encode(encoder, numpy.array([-142, 24]), 4)
encode(encoder, numpy.array([-140, 24]), 4)
encode(encoder, numpy.array([-138, 24]), 4)
encode(encoder, numpy.array([-136, 24]), 4)
encode(encoder, numpy.array([-134, 24]), 4)
encode(encoder, numpy.array([-132, 24]), 4)
encode(encoder, numpy.array([-130, 22]), 4)
encode(encoder, numpy.array([-128, 20]), 4)
encode(encoder, numpy.array([-126, 18]), 5)
encode(encoder, numpy.array([-122, 16]), 5)
encode(encoder, numpy.array([-118, 14]), 6)
encode(encoder, numpy.array([-114, 12]), 7)
encode(encoder, numpy.array([-110, 10]), 8)
encode(encoder, numpy.array([-108, 8]), 9)
encode(encoder, numpy.array([-104, 6]), 10)
encode(encoder, numpy.array([-100, 6]), 11)
encode(encoder, numpy.array([-96, 6]), 12)
encode(encoder, numpy.array([-92, 6]), 13)
encode(encoder, numpy.array([-86, 6]), 13)
encode(encoder, numpy.array([-82, 6]), 13)
encode(encoder, numpy.array([-78, 6]), 13)
encode(encoder, numpy.array([-74, 6]), 13)
encode(encoder, numpy.array([-70, 5]), 13)
encode(encoder, numpy.array([-66, 5]), 13)
encode(encoder, numpy.array([-62, 3]), 13)
encode(encoder, numpy.array([-56, 1]), 13)
encode(encoder, numpy.array([-52, 0]), 13)
encode(encoder, numpy.array([-48, 0]), 13)
encode(encoder, numpy.array([-44, 0]), 13)
encode(encoder, numpy.array([-40, 0]), 13)
encode(encoder, numpy.array([-36, 0]), 13)
encode(encoder, numpy.array([-32, 0]), 13)
encode(encoder, numpy.array([-28, 0]), 10)
encode(encoder, numpy.array([-26, 0]), 8)
encode(encoder, numpy.array([-24, 0]), 6)
encode(encoder, numpy.array([-22, 0]), 4)
encode(encoder, numpy.array([-20, 0]), 4)
encode(encoder, numpy.array([-18, 0]), 4)
encode(encoder, numpy.array([-16, 0]), 4)
encode(encoder, numpy.array([-14, 0]), 4)
def __init__(self,
numInputBits=41,
sensorInputSize=2048,
externalInputSize=2048,
numCorticalColumns=1,
numFeatures=400,
dimension=3,
seed=42):
"""
At creation, the SimpleObjectMachine creates a pool of locations and
features SDR's.
Parameters:
----------------------------
@param numInputBits (int)
Number of ON bits in the input. Note: it should be uneven as the
encoder only accepts uneven number of bits.
@param sensorInputSize (int)
Total number of bits in the sensory input
@param externalInputSize (int)
Total number of bits the external (location) input
@param numCorticalColumns (int)
Number of cortical columns used in the experiment
@param dimension (int)
Dimension of the locations. Will typically be 3.
@param numFeatures (int)
Number of feature SDRs to generate per cortical column. There is
typically no need to not use the default value, unless the user
knows he will use more than 400 patterns.
@param seed (int)
Seed to be used in the machine
"""
super(ContinuousLocationObjectMachine,
self).__init__(numInputBits, sensorInputSize, externalInputSize,
numCorticalColumns, seed)
# location and features pool
self.numFeatures = numFeatures
self._generateFeatures()
self.dimension = dimension
self.locationEncoder = CoordinateEncoder(w=numInputBits,
n=externalInputSize,
name="locationEncoder")
def testEncodeIntoArray(self):
n = 33
w = 3
encoder = CoordinateEncoder(name="coordinate", n=n, w=w)
coordinate = np.array([100, 200])
radius = 5
output1 = encode(encoder, coordinate, radius)
self.assertEqual(np.sum(output1), w)
# Test that we get the same output for the same input
output2 = encode(encoder, coordinate, radius)
self.assertTrue(np.array_equal(output2, output1))
def __init__(self):
self.encoder = CoordinateEncoder(n=1024, w=21)
self.motorEncoder = ScalarEncoder(21, -1, 1, n=1024)
self.tm = MonitoredGeneralTemporalMemory(columnDimensions=[2048],
cellsPerColumn=1,
initialPermanence=0.5,
connectedPermanence=0.6,
permanenceIncrement=0.1,
permanenceDecrement=0.02,
minThreshold=35,
activationThreshold=35,
maxNewSynapseCount=40)
self.plotter = Plotter(self.tm)
self.lastState = None
self.lastAction = None
def __init__(self,
motorValues=range(-4, 4 + 1),
sparsity=0.02,
encoderResolution=0.5,
bmParams=None):
super(PositionBehaviorModel, self).__init__(motorValues=motorValues)
self.encoderResolution = encoderResolution
bmParams = bmParams or {}
numMotorColumns = len(self.motorValues)
bmParams["numMotorColumns"] = numMotorColumns
self.bm = BehaviorMemory(**bmParams)
self.sensorN = self.bm.numSensorColumns
self.sensorW = int(self.sensorN * sparsity) + 1
self.sensorEncoder = CoordinateEncoder(w=self.sensorW, n=self.sensorN)
def testEncodeIntoArray(self):
n = 33
w = 3
encoder = CoordinateEncoder(name="coordinate", n=n, w=w)
coordinate = np.array([100, 200])
radius = 5
output1 = encode(encoder, coordinate, radius)
self.assertEqual(np.sum(output1), w)
# Test that we get the same output for the same input
output2 = encode(encoder, coordinate, radius)
self.assertTrue(np.array_equal(output2, output1))
# Test that a float radius raises an assertion error
with self.assertRaises(AssertionError):
encoder.encode((coordinate, float(radius)))
def overlapsForRelativeAreas(n,
w,
initPosition,
initRadius,
dPosition=None,
dRadius=0,
num=100,
verbose=False):
"""
Return overlaps between an encoding and other encodings relative to it
:param n: the size of the encoder output
:param w: the number of active bits in the encoder output
:param initPosition: the position of the first encoding
:param initRadius: the radius of the first encoding
:param dPosition: the offset to apply to each subsequent position
:param dRadius: the offset to apply to each subsequent radius
:param num: the number of encodings to generate
:param verbose: whether to print verbose output
"""
encoder = CoordinateEncoder(name="coordinate", n=n, w=w)
overlaps = np.empty(num)
outputA = encode(encoder, np.array(initPosition), initRadius)
for i in range(num):
newPosition = initPosition if dPosition == None else (
initPosition + (i + 1) * dPosition)
newRadius = initRadius + (i + 1) * dRadius
outputB = encode(encoder, newPosition, newRadius)
overlaps[i] = overlap(outputA, outputB)
if verbose:
print
print(
"===== Relative encoding overlaps (n = {0}, w = {1}, "
"initPosition = {2}, initRadius = {3}, "
"dPosition = {4}, dRadius = {5}) =====").format(
n, w, initPosition, initRadius, dPosition, dRadius)
print "Average: {0}".format(np.average(overlaps))
print "Max: {0}".format(np.max(overlaps))
return overlaps
def __init__(self):
self.encoder = CoordinateEncoder(n=1024,
w=21)
self.motorEncoder = ScalarEncoder(21, -1, 1,
n=1024)
self.tm = MonitoredExtendedTemporalMemory(
columnDimensions=[2048],
basalInputDimensions: (999999,) # Dodge input checking.
cellsPerColumn=1,
initialPermanence=0.5,
connectedPermanence=0.6,
permanenceIncrement=0.1,
permanenceDecrement=0.02,
minThreshold=35,
activationThreshold=35,
maxNewSynapseCount=40)
self.plotter = Plotter(self.tm, showOverlaps=False, showOverlapsValues=False)
self.lastState = None
self.lastAction = None
self.prevMotorPattern = ()
def setUpClass(cls): registerAllResearchRegions() cls.tmpDir = tempfile.mkdtemp() cls.encoder = CoordinateEncoder(n=1029, w=21, verbosity=0)
def setUp(self):
self.encoder = CoordinateEncoder(name="coordinate", n=33, w=3)
def __init__(self, **kwargs):
# We don't know the sensed value's type, so it's not a spec parameter.
self._sensedValue = None
# coordinate encoder also taking 6400 output SDR with 4% on
self.coordinateEncoder = CoordinateEncoder(n=80 * 80, w=257)
