def run_decoder(self, i, stock_records, mean=True):
encoder = self._get_encoder()
previous_predicted_columns = None
scores = []
input_array = numpy.zeros(encoder.width, dtype="int32")
for i, record in \
enumerate(stock_records):
input_array[:] = numpy.concatenate(encoder.encodeEachField(record))
self.tp.compute(input_array, enableLearn=False, computeInfOutput=True)
active_columns = self.tp.infActiveState['t'].max(axis=1).nonzero()[0].flat
predicted_columns = self.tp.getPredictedState().max(axis=1).nonzero()[0].flat
if previous_predicted_columns is not None:
if mean:
scores.append(computeRawAnomalyScore(active_columns, previous_predicted_columns))
else:
event = EventScore(i, computeRawAnomalyScore(active_columns, previous_predicted_columns),
record.date, record.open_price, record.close_price)
#print event
previous_predicted_columns = predicted_columns
self.tp.reset()
if mean:
return EventScore(i, numpy.mean(scores))
else:
return scores
def run_decoder(self, stock_records):
'''
Run the stock records through the TP without learning.
compute the inference at each step and the anomaly score.
@param stock_records: list type of StockRecord objects
@return the average the anomaly score for the sequence.
'''
# See https://github.com/numenta/nupic/wiki/Anomaly-Detection-and-Anomaly-Scores
data_encoder = self.encoder._get_encoder()
input_array = numpy.zeros(data_encoder.width, dtype="int32")
self.tp.reset()
previous_predicted_columns = None
scores = []
for i, record in enumerate(stock_records):
input_array[:] = numpy.concatenate(data_encoder.encodeEachField(record))
self.tp.compute(input_array, enableLearn=False, computeInfOutput=True)
active_columns = set(self.tp.getActiveState())
predicted_columns = set(self.tp.getPredictedState().max(axis=1).nonzero()[0].flat)
if previous_predicted_columns is not None:
scores.append(computeRawAnomalyScore(active_columns, previous_predicted_columns))
previous_predicted_columns = predicted_columns
return numpy.mean(scores)
def runNetwork(network, numIterations):
network.initialize()
prevPredictedColumns = []
# Run the network showing current values from sensors and their anomaly scores
output = nupic_output.NuPICPlotOutput(["Anomaly Scores"])
for i in range(numIterations):
network.run(1)
if i == 2000:
for p in NETWORK_PARAMS["poolers"]:
network.regions[p["name"]].setParameter("learningMode", False)
spNode = network.regions["spReg1"]
tpNode = network.regions["tpReg1"]
# The anomaly score is relation of active columns over previous predicted columns
activeColumns = spNode.getOutputData("bottomUpOut").nonzero()[0]
anomalyScore = computeRawAnomalyScore(activeColumns, prevPredictedColumns)
output.write(i, anomalyScore)
predictedColumns = tpNode.getOutputData("topDownOut").nonzero()[0]
prevPredictedColumns = copy.deepcopy(predictedColumns)
output.close()
def runNetwork(network, writer):
"""Run the network and write output to writer.
:param network: a Network instance to run
:param writer: a csv.writer instance to write output to
"""
sensorRegion = network.regions["sensor"]
spatialPoolerRegion = network.regions["spatialPoolerRegion"]
temporalPoolerRegion = network.regions["temporalPoolerRegion"]
prevPredictedColumns = []
i = 0
for _ in xrange(_NUM_RECORDS):
# Run the network for a single iteration
network.run(1)
activeColumns = spatialPoolerRegion.getOutputData(
"bottomUpOut").nonzero()[0]
# Calculate the anomaly score using the active columns
# and previous predicted columns
anomalyScore = computeRawAnomalyScore(activeColumns, prevPredictedColumns)
# Write out the anomaly score along with the record number and consumption
# value.
consumption = sensorRegion.getOutputData("sourceOut")[0]
writer.writerow((i, consumption, anomalyScore))
# Store the predicted columns for the next timestep
predictedColumns = temporalPoolerRegion.getOutputData(
"topDownOut").nonzero()[0]
prevPredictedColumns = copy.deepcopy(predictedColumns)
i += 1
def compute(self, inputs, outputs):
activeColumns = inputs["activeColumns"].nonzero()[0]
rawAnomalyScore = anomaly.computeRawAnomalyScore(
activeColumns, self.prevPredictedColumns)
self.prevPredictedColumns = inputs["predictedColumns"].nonzero()[0]
outputs["rawAnomalyScore"][0] = rawAnomalyScore
def compute(self, inputs, outputs):
activeColumns = inputs["activeColumns"].nonzero()[0]
rawAnomalyScore = anomaly.computeRawAnomalyScore(
activeColumns, self.prevPredictedColumns)
self.prevPredictedColumns = inputs["predictedColumns"].nonzero()[0]
outputs["rawAnomalyScore"][0] = rawAnomalyScore
def compute(self, inputs, outputs):
activeColumns = inputs["activeColumns"].nonzero()[0]
rawAnomalyScore = anomaly.computeRawAnomalyScore(
activeColumns, self.prevPredictedColumns)
self.prevPredictedColumns = numpy.array(
inputs["predictedColumns"].nonzero()[0], dtype=numpy.float32)
outputs["rawAnomalyScore"][0] = rawAnomalyScore
def compute(self, inputs, outputs):
activeColumns = inputs["activeColumns"].nonzero()[0]
rawAnomalyScore = anomaly.computeRawAnomalyScore(
activeColumns, self.prevPredictedColumns)
self.prevPredictedColumns = numpy.array(
inputs["predictedColumns"].nonzero()[0], dtype=numpy.float32)
outputs["rawAnomalyScore"][0] = rawAnomalyScore
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 = computeRawAnomalyScore(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 runNetwork(network, writer):
"""Run the network and write output to writer.
:param network: a Network instance to run
:param writer: a csv.writer instance to write output to
"""
sensorRegion = network.regions["sensor"]
spatialPoolerRegion = network.regions["spatialPoolerRegion"]
temporalPoolerRegion = network.regions["temporalPoolerRegion"]
prevPredictedColumns = []
i = 0
for _ in xrange(_NUM_RECORDS):
# Run the network for a single iteration
network.run(1)
activeColumns = spatialPoolerRegion.getOutputData(
"bottomUpOut").nonzero()[0]
# Calculate the anomaly score using the active columns
# and previous predicted columns
anomalyScore = computeRawAnomalyScore(activeColumns,
prevPredictedColumns)
# Write out the anomaly score along with the record number and consumption
# value.
consumption = sensorRegion.getOutputData("sourceOut")[0]
writer.writerow((i, consumption, anomalyScore))
# Store the predicted columns for the next timestep
predictedColumns = temporalPoolerRegion.getOutputData(
"topDownOut").nonzero()[0]
prevPredictedColumns = copy.deepcopy(predictedColumns)
i += 1
def testComputeRawAnomalyScorePartialMatch(self): score = anomaly.computeRawAnomalyScore(array([2, 3, 6]), array([3, 5, 7])) self.assertAlmostEqual(score, 2.0 / 3.0)
def testComputeRawAnomalyScoreNoMatch(self): score = anomaly.computeRawAnomalyScore(array([2, 4, 6]), array([3, 5, 7])) self.assertAlmostEqual(score, 1.0)
def testComputeRawAnomalyScorePerfectMatch(self): score = anomaly.computeRawAnomalyScore(array([3, 5, 7]), array([3, 5, 7])) self.assertAlmostEqual(score, 0.0)
def testComputeRawAnomalyScoreNoActive(self): score = anomaly.computeRawAnomalyScore(array([]), array([3, 5])) self.assertAlmostEqual(score, 0.0)
def handleRecord(self, inputData):
"""
Argument inputData is {"value": instantaneous_value, "timestamp": pandas.Timestamp}
Returns a tuple (anomalyScore, rawScore).
Internally to NuPIC "anomalyScore" corresponds to "likelihood_score"
and "rawScore" corresponds to "anomaly_score". Sorry about that.
"""
# Check for spatial anomalies and update min/max values.
value = inputData["value"]
spatialAnomaly = False
if self.minVal != self.maxVal:
tolerance = (self.maxVal - self.minVal) * SPATIAL_TOLERANCE
maxExpected = self.maxVal + tolerance
minExpected = self.minVal - tolerance
if value > maxExpected or value < minExpected:
spatialAnomaly = True
if self.maxVal is None or value > self.maxVal:
self.maxVal = value
if self.minVal is None or value < self.minVal:
self.minVal = value
# Run the HTM stack. First Encoders.
timestamp = inputData["timestamp"]
timeOfDayBits = np.zeros(self.timeOfDayEncoder.getWidth())
self.timeOfDayEncoder.encodeIntoArray(timestamp, timeOfDayBits)
valueBits = np.zeros(self.value_enc.getWidth())
self.value_enc.encodeIntoArray(value, valueBits)
encoding = np.concatenate([timeOfDayBits, valueBits])
# Spatial Pooler.
activeColumns = np.zeros(self.sp.getNumColumns())
self.sp.compute(encoding, True, activeColumns)
activeColumnIndices = np.nonzero(activeColumns)[0]
# Temporal Memory and Anomaly.
predictions = self.tm.getPredictiveCells()
predictedColumns = list(self.tm.mapCellsToColumns(predictions).keys())
self.tm.compute(activeColumnIndices, learn=True)
activeCells = self.tm.getActiveCells()
rawScore = anomaly.computeRawAnomalyScore(activeColumnIndices,
predictedColumns)
# Compute log(anomaly likelihood)
anomalyScore = self.anomalyLikelihood.anomalyProbability(
inputData["value"], rawScore, inputData["timestamp"])
finalScore = logScore = self.anomalyLikelihood.computeLogLikelihood(
anomalyScore)
if spatialAnomaly:
finalScore = 1.0
if False:
# Plot correlation of excitement versus compartmentalization.
if self.age == 0:
print("Correlation Plots ENABLED.")
if False:
start_age = 1000
end_age = 1800
else:
start_age = 4000
end_age = 7260
if self.age == start_age:
import correlation
import random
self.cor_samplers = []
sampled_cells = []
while len(self.cor_samplers) < 20:
n = random.choice(xrange(self.tm.numberOfCells()))
if n in sampled_cells:
continue
else:
sampled_cells.append(n)
neuron = self.tm.connections.dataForCell(n)
if neuron._roots:
c = correlation.CorrelationSampler(neuron._roots[0])
c.random_sample_points(100)
self.cor_samplers.append(c)
print("Created %d Correlation Samplers" %
len(self.cor_samplers))
if self.age >= start_age:
for smplr in self.cor_samplers:
smplr.sample()
if self.age == end_age:
import matplotlib.pyplot as plt
for idx, smplr in enumerate(self.cor_samplers):
if smplr.num_samples == 0:
print("No samples, plot not shown.")
continue
plt.figure("Sample %d" % idx)
smplr.plot(period=64) # Different value!
plt.show()
if False:
# Plot excitement of a typical detection on a dendrite.
if self.age == 7265:
#if self.age == 1800:
import matplotlib.pyplot as plt
import random
from connections import SYN_CONNECTED_ACTIVE
sampled_cells = set()
for figure_num in xrange(40):
plt.figure("(%d)" % figure_num)
# Find an active cell to view.
cell = None
for attempt in range(100):
event = random.choice(self.tm.activeEvents)
cell = event.cell # This is an integer.
if cell is not None and cell not in sampled_cells:
break
else:
break
sampled_cells.add(cell)
cell = self.tm.connections.dataForCell(cell)
# Organize the data.
EPSPs = []
excitement = []
distance_to_root = 0
segment_offsets = {}
branch = cell._roots[0]
while True:
segment_offsets[branch] = distance_to_root
distance_to_root += len(branch._synapses)
excitement.extend(branch.excitement)
for syn in branch._synapses:
if syn is None:
EPSPs.append(0)
else:
EPSPs.append(syn.state == SYN_CONNECTED_ACTIVE)
if branch.children:
branch = random.choice(branch.children)
else:
break
plt.plot(
np.arange(distance_to_root),
EPSPs,
'r',
np.arange(distance_to_root),
excitement,
'b',
)
plt.title(
"Dendrite Activation\n Horizontal line is activation threshold, Vertical lines are segment bifurcations"
)
plt.xlabel("Distance along Dendrite", )
plt.ylabel("EPSPs are Red, Excitement is Blue")
# Show lines where the excitement crosses thresholds.
plt.axhline(20, color='k') # Hard coded parameter value.
for offset in segment_offsets.values():
if offset != 0:
plt.axvline(offset, color='k')
print("\nShowing %d excitement plots." % len(sampled_cells))
plt.show()
self.age += 1
return (finalScore, rawScore)
def constructClassificationRecord(self, inputs):
"""
Construct a _CLAClassificationRecord based on the state of the model
passed in through the inputs.
Types for self.classificationVectorType:
1 - TP active cells in learn state
2 - SP columns concatenated with error from TP column predictions and SP
"""
# Count the number of unpredicted columns
allSPColumns = inputs["spBottomUpOut"]
activeSPColumns = allSPColumns.nonzero()[0]
score = computeRawAnomalyScore(activeSPColumns,
self._prevPredictedColumns)
spSize = len(allSPColumns)
allTPCells = inputs['tpTopDownOut']
tpSize = len(inputs['tpLrnActiveStateT'])
classificationVector = numpy.array([])
if self.classificationVectorType == 1:
# Classification Vector: [---TP Cells---]
classificationVector = numpy.zeros(tpSize)
activeCellMatrix = inputs["tpLrnActiveStateT"].reshape(tpSize, 1)
activeCellIdx = numpy.where(activeCellMatrix > 0)[0]
if activeCellIdx.shape[0] > 0:
classificationVector[numpy.array(activeCellIdx,
dtype=numpy.uint16)] = 1
elif self.classificationVectorType == 2:
# Classification Vecotr: [---SP---|---(TP-SP)----]
classificationVector = numpy.zeros(spSize + spSize)
if activeSPColumns.shape[0] > 0:
classificationVector[activeSPColumns] = 1.0
errorColumns = numpy.setdiff1d(self._prevPredictedColumns,
activeSPColumns)
if errorColumns.shape[0] > 0:
errorColumnIndexes = (
numpy.array(errorColumns, dtype=numpy.uint16) + spSize)
classificationVector[errorColumnIndexes] = 1.0
else:
raise TypeError(
"Classification vector type must be either 'tpc' or"
" 'sp_tpe', current value is %s" %
(self.classificationVectorType))
# Store the state for next time step
numPredictedCols = len(self._prevPredictedColumns)
predictedColumns = allTPCells.nonzero()[0]
self._prevPredictedColumns = copy.deepcopy(predictedColumns)
if self._anomalyVectorLength is None:
self._anomalyVectorLength = len(classificationVector)
result = _CLAClassificationRecord(
ROWID=self._iteration, #__numRunCalls called
#at beginning of model.run
anomalyScore=score,
anomalyVector=classificationVector.nonzero()[0].tolist(),
anomalyLabel=[])
return result
def input(self, value, recordNum, sequenceNum):
""" Feed the incremented input into the Layer components """
if recordNum == 1:
recordOut = "Monday (1)"
elif recordNum == 2:
recordOut = "Tuesday (2)"
elif recordNum == 3:
recordOut = "Wednesday (3)"
elif recordNum == 4:
recordOut = "Thursday (4)"
elif recordNum == 5:
recordOut = "Friday (5)"
elif recordNum == 6:
recordOut = "Saturday (6)"
else:
recordOut = "Sunday (7)"
if recordNum == 1:
self.theNum += 1
print "--------------------------------------------------------"
print "Iteration: " + str(self.theNum)
self.weeksAnomaly = 0
print "===== " + str(recordOut) + " - Sequence Num: " + str(
sequenceNum) + " ====="
output = np.zeros(sp._columnDimensions)
# Input through encoder
print "ScalarEncoder Input = " + str(value)
encoding = encoder.encode(value)
print "ScalarEncoder Output = " + str(encoding)
bucketIdx = encoder.getBucketIndices(value)[0]
# Input through spatial pooler
sp.compute(encoding, True, output)
print "SpatialPooler Output = " + str(output)
# Input through temporal memory
activesCols = sorted(set(np.where(output > 0)[0].flat))
tm.compute(activesCols, True)
activeCells = tm.getActiveCells() #getSDR(tm.predictiveCells)
predictiveCells = tm.getPredictiveCells()
print "TemporalMemory Input = " + str(input)
# Input into Anomaly Computer
predictiveCols = set()
for c in predictiveCells:
predictiveCols.add(tm.columnForCell(c))
predictiveCols = sorted(predictiveCols)
score = anomaly.computeRawAnomalyScore(activesCols, predictiveCols)
print "input: " + str(activesCols)
print "predi: " + str(predictiveCols)
print "Anomaly Score: " + str(score)
self.weeksAnomaly += score
if recordNum == 7 and self.weeksAnomaly == 0 and self.settleWeek == 0:
self.settleWeek = self.theNum
# Input into classifier
retVal = classifier.compute(recordNum,
patternNZ=activeCells,
classification={
'bucketIdx': bucketIdx,
'actValue': value
},
learn=True,
infer=True)
print "TemporalMemory Prediction = " + str(getSDR(activeCells)) +\
" | CLAClassifier 1 step prob = " + str(retVal[1])
print ""
def _compute(self, inputs, outputs):
"""
Run one iteration of TMRegion's compute
"""
#if self.topDownMode and (not 'topDownIn' in inputs):
# raise RuntimeError("The input topDownIn must be linked in if "
# "topDownMode is True")
if self._tfdr is None:
raise RuntimeError("TM has not been initialized")
# Conditional compute break
self._conditionalBreak()
self._iterations += 1
# Get our inputs as numpy array
buInputVector = inputs['bottomUpIn']
# Handle reset signal
resetSignal = False
if 'resetIn' in inputs:
assert len(inputs['resetIn']) == 1
if inputs['resetIn'][0] != 0:
self._tfdr.reset()
self._sequencePos = 0 # Position within the current sequence
if self.computePredictedActiveCellIndices:
prevPredictedState = self._tfdr.getPredictedState().reshape(-1).astype('float32')
if self.anomalyMode:
prevPredictedColumns = self._tfdr.topDownCompute().copy().nonzero()[0]
# Perform inference and/or learning
tpOutput = self._tfdr.compute(buInputVector, self.learningMode, self.inferenceMode)
self._sequencePos += 1
# OR'ing together the cells in each column?
if self.orColumnOutputs:
tpOutput= tpOutput.reshape(self.columnCount,
self.cellsPerColumn).max(axis=1)
# Direct logging of non-zero TM outputs
if self._fpLogTPOutput:
output = tpOutput.reshape(-1)
outputNZ = tpOutput.nonzero()[0]
outStr = " ".join(["%d" % int(token) for token in outputNZ])
print >>self._fpLogTPOutput, output.size, outStr
# Write the bottom up out to our node outputs
outputs['bottomUpOut'][:] = tpOutput.flat
if self.topDownMode:
# Top-down compute
outputs['topDownOut'][:] = self._tfdr.topDownCompute().copy()
# Set output for use with anomaly classification region if in anomalyMode
if self.anomalyMode:
activeLearnCells = self._tfdr.getLearnActiveStateT()
size = activeLearnCells.shape[0] * activeLearnCells.shape[1]
outputs['lrnActiveStateT'][:] = activeLearnCells.reshape(size)
activeColumns = buInputVector.nonzero()[0]
outputs['anomalyScore'][:] = anomaly.computeRawAnomalyScore(
activeColumns, prevPredictedColumns)
if self.computePredictedActiveCellIndices:
# Reshape so we are dealing with 1D arrays
activeState = self._tfdr._getActiveState().reshape(-1).astype('float32')
activeIndices = numpy.where(activeState != 0)[0]
predictedIndices= numpy.where(prevPredictedState != 0)[0]
predictedActiveIndices = numpy.intersect1d(activeIndices, predictedIndices)
outputs["activeCells"].fill(0)
outputs["activeCells"][activeIndices] = 1
outputs["predictedActiveCells"].fill(0)
outputs["predictedActiveCells"][predictedActiveIndices] = 1
def testComputeRawAnomalyScorePartialMatch(self): score = anomaly.computeRawAnomalyScore(array([2, 3, 6]), array([3, 5, 7])) self.assertAlmostEqual(score, 2.0 / 3.0)
def testComputeRawAnomalyScoreNoMatch(self): score = anomaly.computeRawAnomalyScore(array([2, 4, 6]), array([3, 5, 7])) self.assertAlmostEqual(score, 1.0)
def testComputeRawAnomalyScorePerfectMatch(self): score = anomaly.computeRawAnomalyScore(array([3, 5, 7]), array([3, 5, 7])) self.assertAlmostEqual(score, 0.0)
def testComputeRawAnomalyScoreNoActive(self): score = anomaly.computeRawAnomalyScore(array([]), array([3, 5])) self.assertAlmostEqual(score, 0.0)
def runNetwork(network, numRecords, writer):
"""
Runs specified Network writing the ensuing anomaly
scores to writer.
@param network: The Network instance to be run
@param writer: A csv.writer used to write to output file.
"""
sensorRegion = network.regions[_RECORD_SENSOR]
l1SpRegion = network.regions[_L1_SPATIAL_POOLER]
l1TpRegion = network.regions[_L1_TEMPORAL_MEMORY]
l1Classifier = network.regions[_L1_CLASSIFIER]
l2SpRegion = network.regions[_L2_SPATIAL_POOLER]
l2TpRegion = network.regions[_L2_TEMPORAL_MEMORY]
l2Classifier = network.regions[_L2_CLASSIFIER]
l1PreviousPredictedColumns = []
l2PreviousPredictedColumns = []
l1PreviousPrediction = None
l2PreviousPrediction = None
l1ErrorSum = 0.0
l2ErrorSum = 0.0
for record in xrange(numRecords):
# Run the network for a single iteration
network.run(1)
# Run l1 classifier manually and tally its error score
actual, l1Prediction, l1Confidence = runClassifier(
l1Classifier, sensorRegion, l1TpRegion, record)
if l1PreviousPrediction is not None:
l1ErrorSum += math.fabs(l1PreviousPrediction - actual)
l1PreviousPrediction = l1Prediction
# Run l2 classifier manually and tally its error score
actual, l2Prediction, l2Confidence = runClassifier(
l2Classifier, sensorRegion, l2TpRegion, record)
if l2PreviousPrediction is not None:
l2ErrorSum += math.fabs(l2PreviousPrediction - actual)
l2PreviousPrediction = l2Prediction
# nonzero() returns the indices of the elements that are non-zero,
# here the elements are the indices of the active columns
l1ActiveColumns = l1SpRegion.getOutputData("bottomUpOut").nonzero()[0]
l2ActiveColumns = l2SpRegion.getOutputData("bottomUpOut").nonzero()[0]
# Calculate the anomaly score using the active columns
# and previous predicted columns
l1AnomalyScore = computeRawAnomalyScore(l1ActiveColumns,
l1PreviousPredictedColumns)
l2AnomalyScore = computeRawAnomalyScore(l2ActiveColumns,
l2PreviousPredictedColumns)
# Write record number, actualInput, and anomaly scores
writer.writerow((record, actual, l1AnomalyScore, l2AnomalyScore))
# Store the predicted columns for the next timestep
l1PredictedColumns = l1TpRegion.getOutputData(
"topDownOut").nonzero()[0]
l1PreviousPredictedColumns = copy.deepcopy(l1PredictedColumns)
#
l2PredictedColumns = l2TpRegion.getOutputData(
"topDownOut").nonzero()[0]
l2PreviousPredictedColumns = copy.deepcopy(l2PredictedColumns)
# Output absolute average error for each level
if numRecords > 1:
print "L1 ave abs class. error: %f" % (l1ErrorSum / (numRecords - 1))
print "L2 ave abs class. error: %f" % (l2ErrorSum / (numRecords - 1))
def constructClassificationRecord(self, inputs):
"""
Construct a _CLAClassificationRecord based on the state of the model
passed in through the inputs.
Types for self.classificationVectorType:
1 - TP active cells in learn state
2 - SP columns concatenated with error from TP column predictions and SP
"""
# Count the number of unpredicted columns
allSPColumns = inputs["spBottomUpOut"]
activeSPColumns = allSPColumns.nonzero()[0]
score = computeRawAnomalyScore(activeSPColumns, self._prevPredictedColumns)
spSize = len(allSPColumns)
allTPCells = inputs['tpTopDownOut']
tpSize = len(inputs['tpLrnActiveStateT'])
classificationVector = numpy.array([])
if self.classificationVectorType == 1:
# Classification Vector: [---TP Cells---]
classificationVector = numpy.zeros(tpSize)
activeCellMatrix = inputs["tpLrnActiveStateT"].reshape(tpSize, 1)
activeCellIdx = numpy.where(activeCellMatrix > 0)[0]
if activeCellIdx.shape[0] > 0:
classificationVector[numpy.array(activeCellIdx, dtype=numpy.uint16)] = 1
elif self.classificationVectorType == 2:
# Classification Vecotr: [---SP---|---(TP-SP)----]
classificationVector = numpy.zeros(spSize+spSize)
if activeSPColumns.shape[0] > 0:
classificationVector[activeSPColumns] = 1.0
errorColumns = numpy.setdiff1d(self._prevPredictedColumns,
activeSPColumns)
if errorColumns.shape[0] > 0:
errorColumnIndexes = ( numpy.array(errorColumns, dtype=numpy.uint16) +
spSize )
classificationVector[errorColumnIndexes] = 1.0
else:
raise TypeError("Classification vector type must be either 'tpc' or"
" 'sp_tpe', current value is %s" % (self.classificationVectorType))
# Store the state for next time step
numPredictedCols = len(self._prevPredictedColumns)
predictedColumns = allTPCells.nonzero()[0]
self._prevPredictedColumns = copy.deepcopy(predictedColumns)
if self._anomalyVectorLength is None:
self._anomalyVectorLength = len(classificationVector)
result = _CLAClassificationRecord(
ROWID=self._iteration, #__numRunCalls called
#at beginning of model.run
anomalyScore=score,
anomalyVector=classificationVector.nonzero()[0].tolist(),
anomalyLabel=[]
)
return result
def _compute(self, inputs, outputs):
"""
Run one iteration of TPRegion's compute
"""
#if self.topDownMode and (not 'topDownIn' in inputs):
# raise RuntimeError("The input topDownIn must be linked in if "
# "topDownMode is True")
if self._tfdr is None:
raise RuntimeError("TP has not been initialized")
# Conditional compute break
self._conditionalBreak()
self._iterations += 1
# Get our inputs as numpy array
buInputVector = inputs['bottomUpIn']
# Handle reset signal
resetSignal = False
if 'resetIn' in inputs:
assert len(inputs['resetIn']) == 1
if inputs['resetIn'][0] != 0:
self._tfdr.reset()
self._sequencePos = 0 # Position within the current sequence
if self.computePredictedActiveCellIndices:
prevPredictedState = self._tfdr.getPredictedState().reshape(
-1).astype('float32')
if self.anomalyMode:
prevPredictedColumns = self._tfdr.topDownCompute().copy().nonzero(
)[0]
# Perform inference and/or learning
tpOutput = self._tfdr.compute(buInputVector, self.learningMode,
self.inferenceMode)
self._sequencePos += 1
# OR'ing together the cells in each column?
if self.orColumnOutputs:
tpOutput = tpOutput.reshape(self.columnCount,
self.cellsPerColumn).max(axis=1)
# Direct logging of non-zero TP outputs
if self._fpLogTPOutput:
output = tpOutput.reshape(-1)
outputNZ = tpOutput.nonzero()[0]
outStr = " ".join(["%d" % int(token) for token in outputNZ])
print >> self._fpLogTPOutput, output.size, outStr
# Write the bottom up out to our node outputs
outputs['bottomUpOut'][:] = tpOutput.flat
if self.topDownMode:
# Top-down compute
outputs['topDownOut'][:] = self._tfdr.topDownCompute().copy()
# Set output for use with anomaly classification region if in anomalyMode
if self.anomalyMode:
activeLearnCells = self._tfdr.getLearnActiveStateT()
size = activeLearnCells.shape[0] * activeLearnCells.shape[1]
outputs['lrnActiveStateT'][:] = activeLearnCells.reshape(size)
activeColumns = buInputVector.nonzero()[0]
outputs['anomalyScore'][:] = anomaly.computeRawAnomalyScore(
activeColumns, prevPredictedColumns)
if self.computePredictedActiveCellIndices:
# Reshape so we are dealing with 1D arrays
activeState = self._tfdr.getActiveState().reshape(-1).astype(
'float32')
activeIndices = numpy.where(activeState != 0)[0]
predictedIndices = numpy.where(prevPredictedState != 0)[0]
predictedActiveIndices = numpy.intersect1d(activeIndices,
predictedIndices)
outputs['predictedActiveCells'].fill(0)
outputs['predictedActiveCells'][predictedActiveIndices] = 1
def runNetwork(network, numRecords, writer):
"""
Runs specified Network writing the ensuing anomaly
scores to writer.
@param network: The Network instance to be run
@param writer: A csv.writer used to write to output file.
"""
sensorRegion = network.regions[_RECORD_SENSOR]
l1SpRegion = network.regions[_L1_SPATIAL_POOLER]
l1TpRegion = network.regions[_L1_TEMPORAL_MEMORY]
l1Classifier = network.regions[_L1_CLASSIFIER]
l2SpRegion = network.regions[_L2_SPATIAL_POOLER]
l2TpRegion = network.regions[_L2_TEMPORAL_MEMORY]
l2Classifier = network.regions[_L2_CLASSIFIER]
l1PreviousPredictedColumns = []
l2PreviousPredictedColumns = []
l1PreviousPrediction = None
l2PreviousPrediction = None
l1ErrorSum = 0.0
l2ErrorSum = 0.0
for record in xrange(numRecords):
# Run the network for a single iteration
network.run(1)
# Run l1 classifier manually and tally its error score
actual, l1Prediction, l1Confidence = runClassifier(l1Classifier,
sensorRegion,
l1TpRegion, record)
if l1PreviousPrediction is not None:
l1ErrorSum += math.fabs(l1PreviousPrediction - actual)
l1PreviousPrediction = l1Prediction
# Run l2 classifier manually and tally its error score
actual, l2Prediction, l2Confidence = runClassifier(l2Classifier,
sensorRegion,
l2TpRegion, record)
if l2PreviousPrediction is not None:
l2ErrorSum += math.fabs(l2PreviousPrediction - actual)
l2PreviousPrediction = l2Prediction
# nonzero() returns the indices of the elements that are non-zero,
# here the elements are the indices of the active columns
l1ActiveColumns = l1SpRegion.getOutputData("bottomUpOut").nonzero()[0]
l2ActiveColumns = l2SpRegion.getOutputData("bottomUpOut").nonzero()[0]
# Calculate the anomaly score using the active columns
# and previous predicted columns
l1AnomalyScore = computeRawAnomalyScore(l1ActiveColumns,
l1PreviousPredictedColumns)
l2AnomalyScore = computeRawAnomalyScore(l2ActiveColumns,
l2PreviousPredictedColumns)
# Write record number, actualInput, and anomaly scores
writer.writerow((record, actual, l1AnomalyScore, l2AnomalyScore))
# Store the predicted columns for the next timestep
l1PredictedColumns = l1TpRegion.getOutputData("topDownOut").nonzero()[0]
l1PreviousPredictedColumns = copy.deepcopy(l1PredictedColumns)
#
l2PredictedColumns = l2TpRegion.getOutputData("topDownOut").nonzero()[0]
l2PreviousPredictedColumns = copy.deepcopy(l2PredictedColumns)
# Output absolute average error for each level
if numRecords > 1:
print "L1 ave abs class. error: %f" % (l1ErrorSum / (numRecords - 1))
print "L2 ave abs class. error: %f" % (l2ErrorSum / (numRecords - 1))
