def __init__(
self,
inputDimensions=[32, 32],
columnDimensions=[64, 64],
potentialRadius=16,
potentialPct=0.9,
globalInhibition=True,
localAreaDensity=-1.0,
numActiveColumnsPerInhArea=20.0,
stimulusThreshold=2,
synPermInactiveDec=0.01,
synPermActiveInc=0.03,
synPermConnected=0.3,
minPctOverlapDutyCycle=0.001,
minPctActiveDutyCycle=0.001,
dutyCyclePeriod=1000,
maxBoost=1.0,
seed=42,
spVerbosity=0,
wrapAround=True,
# union_pooler.py parameters
activeOverlapWeight=1.0,
predictedActiveOverlapWeight=0.0,
fixedPoolingActivationBurst=False,
exciteFunction=None,
decayFunction=None,
maxUnionActivity=0.20,
):
"""
Please see spatial_pooler.py in NuPIC for super class parameter
descriptions.
Class-specific parameters:
-------------------------------------
@param activeOverlapWeight: A multiplicative weight applied to
the overlap between connected synapses and active-cell input
@param predictedActiveOverlapWeight: A multiplicative weight applied to
the overlap between connected synapses and predicted-active-cell input
@param fixedPoolingActivationBurst: A Boolean, which, if True, has the
Union Pooler grant a fixed amount of pooling activation to
columns whenever they win the inhibition step. If False, columns'
pooling activation is calculated based on their current overlap.
@param exciteFunction: If fixedPoolingActivationBurst is False,
this specifies the ExciteFunctionBase used to excite pooling
activation.
@param decayFunction: Specifies the DecayFunctionBase used to decay pooling
activation.
@param maxUnionActivity: Maximum number of active cells allowed in union SDR
simultaneously in terms of the ratio between the number of active cells
and the number of total cells
"""
super(UnionPooler, self).__init__(
inputDimensions,
columnDimensions,
potentialRadius,
potentialPct,
globalInhibition,
localAreaDensity,
numActiveColumnsPerInhArea,
stimulusThreshold,
synPermInactiveDec,
synPermActiveInc,
synPermConnected,
minPctOverlapDutyCycle,
minPctActiveDutyCycle,
dutyCyclePeriod,
maxBoost,
seed,
spVerbosity,
wrapAround,
)
self._activeOverlapWeight = activeOverlapWeight
self._predictedActiveOverlapWeight = predictedActiveOverlapWeight
self._fixedPoolingActivationBurst = fixedPoolingActivationBurst
self._maxUnionActivity = maxUnionActivity
if exciteFunction is None:
self._exciteFunction = LinearExciteFunction()
else:
self._exciteFunction = exciteFunction
if decayFunction is None:
self._decayFunction = NoDecayFunction()
else:
self._decayFunction = decayFunction
# The maximum number of cells allowed in a single union SDR
self._maxUnionCells = int(self._numColumns * self._maxUnionActivity)
# Scalar activation of potential union SDR cells; most active cells become
# the union SDR
self._poolingActivation = numpy.zeros(self._numColumns, dtype=REAL_DTYPE)
# Current union SDR; the end product of the union pooler algorithm
self._unionSDR = numpy.array([], dtype=INT_DTYPE)
def __init__(
self,
inputDimensions=[32, 32],
columnDimensions=[64, 64],
potentialRadius=16,
potentialPct=0.9,
globalInhibition=True,
localAreaDensity=-1.0,
numActiveColumnsPerInhArea=20.0,
stimulusThreshold=2,
synPermInactiveDec=0.01,
synPermActiveInc=0.03,
synPermConnected=0.3,
minPctOverlapDutyCycle=0.001,
minPctActiveDutyCycle=0.001,
dutyCyclePeriod=1000,
maxBoost=1.0,
seed=42,
spVerbosity=0,
wrapAround=True,
# union_pooler.py parameters
activeOverlapWeight=1.0,
predictedActiveOverlapWeight=0.0,
fixedPoolingActivationBurst=False,
exciteFunction=None,
decayFunction=None,
maxUnionActivity=0.20):
"""
Please see spatial_pooler.py in NuPIC for super class parameter
descriptions.
Class-specific parameters:
-------------------------------------
@param activeOverlapWeight: A multiplicative weight applied to
the overlap between connected synapses and active-cell input
@param predictedActiveOverlapWeight: A multiplicative weight applied to
the overlap between connected synapses and predicted-active-cell input
@param fixedPoolingActivationBurst: A Boolean, which, if True, has the
Union Pooler grant a fixed amount of pooling activation to
columns whenever they win the inhibition step. If False, columns'
pooling activation is calculated based on their current overlap.
@param exciteFunction: If fixedPoolingActivationBurst is False,
this specifies the ExciteFunctionBase used to excite pooling
activation.
@param decayFunction: Specifies the DecayFunctionBase used to decay pooling
activation.
@param maxUnionActivity: Maximum number of active cells allowed in union SDR
simultaneously in terms of the ratio between the number of active cells
and the number of total cells
"""
super(UnionPooler, self).__init__(
inputDimensions, columnDimensions, potentialRadius, potentialPct,
globalInhibition, localAreaDensity, numActiveColumnsPerInhArea,
stimulusThreshold, synPermInactiveDec, synPermActiveInc,
synPermConnected, minPctOverlapDutyCycle, minPctActiveDutyCycle,
dutyCyclePeriod, maxBoost, seed, spVerbosity, wrapAround)
self._activeOverlapWeight = activeOverlapWeight
self._predictedActiveOverlapWeight = predictedActiveOverlapWeight
self._fixedPoolingActivationBurst = fixedPoolingActivationBurst
self._maxUnionActivity = maxUnionActivity
if exciteFunction is None:
self._exciteFunction = LinearExciteFunction()
else:
self._exciteFunction = exciteFunction
if decayFunction is None:
self._decayFunction = NoDecayFunction()
else:
self._decayFunction = decayFunction
# The maximum number of cells allowed in a single union SDR
self._maxUnionCells = int(self._numColumns * self._maxUnionActivity)
# Scalar activation of potential union SDR cells; most active cells become
# the union SDR
self._poolingActivation = numpy.zeros(self._numColumns,
dtype=REAL_DTYPE)
# Current union SDR; the end product of the union pooler algorithm
self._unionSDR = numpy.array([], dtype=INT_DTYPE)
class UnionPooler(SpatialPooler):
"""
Experimental Union Pooler Python implementation. The Union Pooler builds a
"union SDR" of the most recent sets of active columns. It is driven by
active-cell input and, more strongly, by predictive-active cell input. The
latter is more likely to produce active columns. Such winning columns will
also tend to persist longer in the union SDR.
"""
def __init__(
self,
inputDimensions=[32, 32],
columnDimensions=[64, 64],
potentialRadius=16,
potentialPct=0.9,
globalInhibition=True,
localAreaDensity=-1.0,
numActiveColumnsPerInhArea=20.0,
stimulusThreshold=2,
synPermInactiveDec=0.01,
synPermActiveInc=0.03,
synPermConnected=0.3,
minPctOverlapDutyCycle=0.001,
minPctActiveDutyCycle=0.001,
dutyCyclePeriod=1000,
maxBoost=1.0,
seed=42,
spVerbosity=0,
wrapAround=True,
# union_pooler.py parameters
activeOverlapWeight=1.0,
predictedActiveOverlapWeight=0.0,
fixedPoolingActivationBurst=False,
exciteFunction=None,
decayFunction=None,
maxUnionActivity=0.20,
):
"""
Please see spatial_pooler.py in NuPIC for super class parameter
descriptions.
Class-specific parameters:
-------------------------------------
@param activeOverlapWeight: A multiplicative weight applied to
the overlap between connected synapses and active-cell input
@param predictedActiveOverlapWeight: A multiplicative weight applied to
the overlap between connected synapses and predicted-active-cell input
@param fixedPoolingActivationBurst: A Boolean, which, if True, has the
Union Pooler grant a fixed amount of pooling activation to
columns whenever they win the inhibition step. If False, columns'
pooling activation is calculated based on their current overlap.
@param exciteFunction: If fixedPoolingActivationBurst is False,
this specifies the ExciteFunctionBase used to excite pooling
activation.
@param decayFunction: Specifies the DecayFunctionBase used to decay pooling
activation.
@param maxUnionActivity: Maximum number of active cells allowed in union SDR
simultaneously in terms of the ratio between the number of active cells
and the number of total cells
"""
super(UnionPooler, self).__init__(
inputDimensions,
columnDimensions,
potentialRadius,
potentialPct,
globalInhibition,
localAreaDensity,
numActiveColumnsPerInhArea,
stimulusThreshold,
synPermInactiveDec,
synPermActiveInc,
synPermConnected,
minPctOverlapDutyCycle,
minPctActiveDutyCycle,
dutyCyclePeriod,
maxBoost,
seed,
spVerbosity,
wrapAround,
)
self._activeOverlapWeight = activeOverlapWeight
self._predictedActiveOverlapWeight = predictedActiveOverlapWeight
self._fixedPoolingActivationBurst = fixedPoolingActivationBurst
self._maxUnionActivity = maxUnionActivity
if exciteFunction is None:
self._exciteFunction = LinearExciteFunction()
else:
self._exciteFunction = exciteFunction
if decayFunction is None:
self._decayFunction = NoDecayFunction()
else:
self._decayFunction = decayFunction
# The maximum number of cells allowed in a single union SDR
self._maxUnionCells = int(self._numColumns * self._maxUnionActivity)
# Scalar activation of potential union SDR cells; most active cells become
# the union SDR
self._poolingActivation = numpy.zeros(self._numColumns, dtype=REAL_DTYPE)
# Current union SDR; the end product of the union pooler algorithm
self._unionSDR = numpy.array([], dtype=INT_DTYPE)
def reset(self):
"""
Reset the state of the Union Pooler.
"""
# Reset Union Pooler fields
self._poolingActivation = numpy.zeros(self._numColumns, dtype=REAL_DTYPE)
self._unionSDR = []
# Reset Spatial Pooler fields
self._overlapDutyCycles = numpy.zeros(self._numColumns, dtype=REAL_DTYPE)
self._activeDutyCycles = numpy.zeros(self._numColumns, dtype=REAL_DTYPE)
self._minOverlapDutyCycles = numpy.zeros(self._numColumns, dtype=REAL_DTYPE)
self._minActiveDutyCycles = numpy.zeros(self._numColumns, dtype=REAL_DTYPE)
self._boostFactors = numpy.ones(self._numColumns, dtype=REAL_DTYPE)
def compute(self, activeInput, predictedActiveInput, learn):
"""
Computes one cycle of the Union Pooler algorithm.
"""
assert numpy.size(activeInput) == self._numInputs
assert numpy.size(predictedActiveInput) == self._numInputs
self._updateBookeepingVars(learn)
# Compute proximal dendrite overlaps with active and active-predicted inputs
overlapsActive = self._calculateOverlap(activeInput)
overlapsPredictedActive = self._calculateOverlap(predictedActiveInput)
totalOverlap = (
overlapsActive * self._activeOverlapWeight + overlapsPredictedActive * self._predictedActiveOverlapWeight
)
if learn:
boostedOverlaps = self._boostFactors * totalOverlap
else:
boostedOverlaps = totalOverlap
activeCells = self._inhibitColumns(boostedOverlaps)
if learn:
self._adaptSynapses(activeInput, activeCells)
self._updateDutyCycles(totalOverlap, activeCells)
self._bumpUpWeakColumns()
self._updateBoostFactors()
if self._isUpdateRound():
self._updateInhibitionRadius()
self._updateMinDutyCycles()
# Decrement pooling activation of all cells
self._decayPoolingActivation()
# Reset the poolingActivation of current active Union Pooler cells
if self._fixedPoolingActivationBurst:
# Increase is based on fixed parameter
tieBreaker = [random.random() * _TIE_BREAKER_FACTOR for _ in xrange(len(activeCells))]
self._poolingActivation[activeCells] = self._poolingActivationBurst + tieBreaker
else:
# PoolingActivation update is based on active & predicted-active overlap
self._addToPoolingActivation(activeCells, overlapsActive)
self._addToPoolingActivation(activeCells, overlapsPredictedActive)
return self._getMostActiveCells()
def _decayPoolingActivation(self):
"""
Decrements pooling activation of all cells
"""
self._poolingActivation = self._decayFunction.decay(self._poolingActivation, 1)
self._poolingActivation[self._poolingActivation < 0] = 0
return self._poolingActivation
def _addToPoolingActivation(self, activeCells, overlaps):
"""
Adds overlaps from specified active cells to cells' pooling
activation.
:param activeCells: Indices of those cells winning the inhibition step
:param overlaps: A current set of overlap values for each cell
"""
cellIndices = numpy.where(overlaps[activeCells] > 0)[0]
subset = activeCells[cellIndices]
self._poolingActivation[subset] = self._exciteFunction.excite(self._poolingActivation[subset], overlaps[subset])
return self._poolingActivation
def _getMostActiveCells(self):
"""
Gets the most active cells in the Union SDR having at least non-zero
activation in sorted order.
:return: a list of cell indices
"""
potentialUnionSDR = numpy.argsort(self._poolingActivation)[::-1][: len(self._poolingActivation)]
topCells = potentialUnionSDR[0 : self._maxUnionCells]
nonZeroTopCells = self._poolingActivation[topCells] > 0
self._unionSDR = numpy.sort(topCells[nonZeroTopCells]).astype(INT_DTYPE)
return self._unionSDR
def getUnionSDR(self):
return self._unionSDR
class UnionPooler(SpatialPooler):
"""
Experimental Union Pooler Python implementation. The Union Pooler builds a
"union SDR" of the most recent sets of active columns. It is driven by
active-cell input and, more strongly, by predictive-active cell input. The
latter is more likely to produce active columns. Such winning columns will
also tend to persist longer in the union SDR.
"""
def __init__(
self,
inputDimensions=[32, 32],
columnDimensions=[64, 64],
potentialRadius=16,
potentialPct=0.9,
globalInhibition=True,
localAreaDensity=-1.0,
numActiveColumnsPerInhArea=20.0,
stimulusThreshold=2,
synPermInactiveDec=0.01,
synPermActiveInc=0.03,
synPermConnected=0.3,
minPctOverlapDutyCycle=0.001,
minPctActiveDutyCycle=0.001,
dutyCyclePeriod=1000,
maxBoost=1.0,
seed=42,
spVerbosity=0,
wrapAround=True,
# union_pooler.py parameters
activeOverlapWeight=1.0,
predictedActiveOverlapWeight=0.0,
fixedPoolingActivationBurst=False,
exciteFunction=None,
decayFunction=None,
maxUnionActivity=0.20):
"""
Please see spatial_pooler.py in NuPIC for super class parameter
descriptions.
Class-specific parameters:
-------------------------------------
@param activeOverlapWeight: A multiplicative weight applied to
the overlap between connected synapses and active-cell input
@param predictedActiveOverlapWeight: A multiplicative weight applied to
the overlap between connected synapses and predicted-active-cell input
@param fixedPoolingActivationBurst: A Boolean, which, if True, has the
Union Pooler grant a fixed amount of pooling activation to
columns whenever they win the inhibition step. If False, columns'
pooling activation is calculated based on their current overlap.
@param exciteFunction: If fixedPoolingActivationBurst is False,
this specifies the ExciteFunctionBase used to excite pooling
activation.
@param decayFunction: Specifies the DecayFunctionBase used to decay pooling
activation.
@param maxUnionActivity: Maximum number of active cells allowed in union SDR
simultaneously in terms of the ratio between the number of active cells
and the number of total cells
"""
super(UnionPooler, self).__init__(
inputDimensions, columnDimensions, potentialRadius, potentialPct,
globalInhibition, localAreaDensity, numActiveColumnsPerInhArea,
stimulusThreshold, synPermInactiveDec, synPermActiveInc,
synPermConnected, minPctOverlapDutyCycle, minPctActiveDutyCycle,
dutyCyclePeriod, maxBoost, seed, spVerbosity, wrapAround)
self._activeOverlapWeight = activeOverlapWeight
self._predictedActiveOverlapWeight = predictedActiveOverlapWeight
self._fixedPoolingActivationBurst = fixedPoolingActivationBurst
self._maxUnionActivity = maxUnionActivity
if exciteFunction is None:
self._exciteFunction = LinearExciteFunction()
else:
self._exciteFunction = exciteFunction
if decayFunction is None:
self._decayFunction = NoDecayFunction()
else:
self._decayFunction = decayFunction
# The maximum number of cells allowed in a single union SDR
self._maxUnionCells = int(self._numColumns * self._maxUnionActivity)
# Scalar activation of potential union SDR cells; most active cells become
# the union SDR
self._poolingActivation = numpy.zeros(self._numColumns,
dtype=REAL_DTYPE)
# Current union SDR; the end product of the union pooler algorithm
self._unionSDR = numpy.array([], dtype=INT_DTYPE)
def reset(self):
"""
Reset the state of the Union Pooler.
"""
# Reset Union Pooler fields
self._poolingActivation = numpy.zeros(self._numColumns,
dtype=REAL_DTYPE)
self._unionSDR = []
# Reset Spatial Pooler fields
self._overlapDutyCycles = numpy.zeros(self._numColumns,
dtype=REAL_DTYPE)
self._activeDutyCycles = numpy.zeros(self._numColumns,
dtype=REAL_DTYPE)
self._minOverlapDutyCycles = numpy.zeros(self._numColumns,
dtype=REAL_DTYPE)
self._minActiveDutyCycles = numpy.zeros(self._numColumns,
dtype=REAL_DTYPE)
self._boostFactors = numpy.ones(self._numColumns, dtype=REAL_DTYPE)
def compute(self, activeInput, predictedActiveInput, learn):
"""
Computes one cycle of the Union Pooler algorithm.
"""
assert numpy.size(activeInput) == self._numInputs
assert numpy.size(predictedActiveInput) == self._numInputs
self._updateBookeepingVars(learn)
# Compute proximal dendrite overlaps with active and active-predicted inputs
overlapsActive = self._calculateOverlap(activeInput)
overlapsPredictedActive = self._calculateOverlap(predictedActiveInput)
totalOverlap = (
overlapsActive * self._activeOverlapWeight +
overlapsPredictedActive * self._predictedActiveOverlapWeight)
if learn:
boostedOverlaps = self._boostFactors * totalOverlap
else:
boostedOverlaps = totalOverlap
activeCells = self._inhibitColumns(boostedOverlaps)
if learn:
self._adaptSynapses(activeInput, activeCells)
self._updateDutyCycles(totalOverlap, activeCells)
self._bumpUpWeakColumns()
self._updateBoostFactors()
if self._isUpdateRound():
self._updateInhibitionRadius()
self._updateMinDutyCycles()
# Decrement pooling activation of all cells
self._decayPoolingActivation()
# Reset the poolingActivation of current active Union Pooler cells
if self._fixedPoolingActivationBurst:
# Increase is based on fixed parameter
tieBreaker = [
random.random() * _TIE_BREAKER_FACTOR
for _ in xrange(len(activeCells))
]
self._poolingActivation[activeCells] = (
self._poolingActivationBurst + tieBreaker)
else:
# PoolingActivation update is based on active & predicted-active overlap
self._addToPoolingActivation(activeCells, overlapsActive)
self._addToPoolingActivation(activeCells, overlapsPredictedActive)
return self._getMostActiveCells()
def _decayPoolingActivation(self):
"""
Decrements pooling activation of all cells
"""
self._poolingActivation = self._decayFunction.decay(
self._poolingActivation, 1)
self._poolingActivation[self._poolingActivation < 0] = 0
return self._poolingActivation
def _addToPoolingActivation(self, activeCells, overlaps):
"""
Adds overlaps from specified active cells to cells' pooling
activation.
:param activeCells: Indices of those cells winning the inhibition step
:param overlaps: A current set of overlap values for each cell
"""
cellIndices = numpy.where(overlaps[activeCells] > 0)[0]
subset = activeCells[cellIndices]
self._poolingActivation[subset] = self._exciteFunction.excite(
self._poolingActivation[subset], overlaps[subset])
return self._poolingActivation
def _getMostActiveCells(self):
"""
Gets the most active cells in the Union SDR having at least non-zero
activation in sorted order.
:return: a list of cell indices
"""
potentialUnionSDR = numpy.argsort(
self._poolingActivation)[::-1][:len(self._poolingActivation)]
topCells = potentialUnionSDR[0:self._maxUnionCells]
nonZeroTopCells = self._poolingActivation[topCells] > 0
self._unionSDR = numpy.sort(
topCells[nonZeroTopCells]).astype(INT_DTYPE)
return self._unionSDR
def getUnionSDR(self):
return self._unionSDR