def __init__(self, world, parameters=default_parameters):
self.world = world
self.area_size = parameters['num_cells']
self.num_areas = len(self.world.coordinates)
# Make an RDSE for every location.
self.enc = np.zeros(self.world.dims, dtype=object)
enc_parameters = RDSE_Parameters()
enc_parameters.size = self.area_size
enc_parameters.sparsity = parameters['local_sparsity']
enc_parameters.category = True
for coords in self.world.coordinates:
self.enc[coords] = RDSE(enc_parameters)
# Make empty buffers for the working data.
self.local = np.zeros(self.world.dims, dtype=object)
self.gnw = np.zeros(self.world.dims, dtype=object)
for coords in self.world.coordinates:
self.local[coords] = SDR((self.area_size, ))
self.gnw[coords] = SDR((self.area_size, ))
# Make an instance of the model at every location.
self.apical_denrites = np.zeros(self.world.dims, dtype=object)
self.gnw_size = self.num_areas * self.area_size
for coords in self.world.coordinates:
self.apical_denrites[coords] = TemporalMemory(
[self.area_size], # column_dimensions
cellsPerColumn=1,
externalPredictiveInputs=self.gnw_size,
seed=0,
**parameters['apical_denrites'])
def create_encoder(self):
print("creating encoder...")
print(self.setting("enc"))
scalarEncoderParams = RDSE_Parameters()
scalarEncoderParams.size = self.setting("enc").size
scalarEncoderParams.sparsity = self.setting("enc").sparsity
scalarEncoderParams.resolution = self.setting("enc").resolution
scalarEncoder = RDSE(scalarEncoderParams)
print()
return scalarEncoder
def _createRDSE(self, min_val=0, max_val=0):
scalarEncoderParams = RDSE_Parameters()
scalarEncoderParams.size = self.parameters["enc"]["value"]["size"]
scalarEncoderParams.activeBits = self.parameters["enc"]["value"]["activeBits"]
scalarEncoderParams.resolution = max(0.001, (max_val - min_val) / 130)
scalarEncoderParams.seed = self.parameters["enc"]["value"]["seed"]
return RDSE(scalarEncoderParams)
def sacler_data_randonscaler_method_1():
pooler_data = []
data = pickle.load(open('data/x_hat_v3.pkl', mode='rb'))
col1 = data[:, 0:1].flatten()
col2 = data[:, 1:2].flatten()
col3 = data[:, 2:3].flatten()
col4 = data[:, 3:4].flatten()
parameter1 = RDSE_Parameters()
parameter1.size = 2000
parameter1.sparsity = 0.02
parameter1.resolution = 0.66
rsc1 = RDSE(parameter1)
# Create SDR for 3D TSNE input plus one for magnitude for 128 D original vector.
# Loop through all vectors one at the time
# to create SDe for SP.
for _x1, _x2, _x3, _x4 in zip(col1, col2, col3, col4):
x_x1 = rsc1.encode(_x1)
x_x2 = rsc1.encode(_x2)
x_x3 = rsc1.encode(_x3)
x_x4 = rsc1.encode(_x4)
pooler_data.append(SDR(8000).concatenate([x_x1, x_x2, x_x3, x_x4]))
return pooler_data
def SystemSetup(parameters, verbose=True):
global agent, sensorEncoder, env, sensorLayer_sp, sensorLayer_SDR_columns
global gridCellEncoder, locationlayer_SDR_cells
global sensorLayer_tm
if verbose:
import pprint
print("Parameters:")
pprint.pprint(parameters, indent=4)
print("")
# create environment and the agent
env = htm2d.environment.TwoDimensionalEnvironment(20, 20)
agent = htm2d.agent.Agent()
# load object from yml file
with open(os.path.join(_OBJECTS_DIR, OBJECT_FILENAME), "r") as stream:
try:
env.load_object(stream)
except yaml.YAMLError as exc:
print(exc)
# SENSOR LAYER --------------------------------------------------------------
# setup sensor encoder
sensorEncoderParams = RDSE_Parameters()
sensorEncoderParams.category = True
sensorEncoderParams.size = parameters["enc"]["size"]
sensorEncoderParams.sparsity = parameters["enc"]["sparsity"]
sensorEncoderParams.seed = parameters["enc"]["seed"]
sensorEncoder = RDSE(sensorEncoderParams)
# Create SpatialPooler
spParams = parameters["sensorLayer_sp"]
sensorLayer_sp = SpatialPooler(
inputDimensions=(sensorEncoder.size, ),
columnDimensions=(spParams["columnCount"], ),
potentialPct=spParams["potentialPct"],
potentialRadius=sensorEncoder.size,
globalInhibition=True,
localAreaDensity=spParams["localAreaDensity"],
synPermInactiveDec=spParams["synPermInactiveDec"],
synPermActiveInc=spParams["synPermActiveInc"],
synPermConnected=spParams["synPermConnected"],
boostStrength=spParams["boostStrength"],
wrapAround=True,
)
sp_info = Metrics(sensorLayer_sp.getColumnDimensions(), 999999999)
# Create an SDR to represent active columns, This will be populated by the
# compute method below. It must have the same dimensions as the Spatial Pooler.
sensorLayer_SDR_columns = SDR(spParams["columnCount"])
# LOCATION LAYER ------------------------------------------------------------
# Grid cell modules
locParams = parameters["locationLayer"]
gridCellEncoder = GridCellEncoder(
size=locParams["cellCount"],
sparsity=locParams["sparsity"],
periods=locParams["periods"],
seed=locParams["seed"],
)
locationlayer_SDR_cells = SDR(gridCellEncoder.dimensions)
tmParams = parameters["sensorLayer_tm"]
sensorLayer_tm = TemporalMemory(
columnDimensions=(spParams["columnCount"], ),
cellsPerColumn=tmParams["cellsPerColumn"],
activationThreshold=tmParams["activationThreshold"],
initialPermanence=tmParams["initialPerm"],
connectedPermanence=spParams["synPermConnected"],
minThreshold=tmParams["minThreshold"],
maxNewSynapseCount=tmParams["newSynapseCount"],
permanenceIncrement=tmParams["permanenceInc"],
permanenceDecrement=tmParams["permanenceDec"],
predictedSegmentDecrement=0.0,
maxSegmentsPerCell=tmParams["maxSegmentsPerCell"],
maxSynapsesPerSegment=tmParams["maxSynapsesPerSegment"],
externalPredictiveInputs=locParams["cellCount"],
)
tm_info = Metrics([sensorLayer_tm.numberOfCells()], 999999999)
def building_htm(len_data):
global enc_info
global sp_info
global tm_info
global anomaly_history
global predictor
global predictor_resolution
global tm
global sp
global scalarEncoder
global encodingWidth
global dateEncoder
# Initial message
print("Building HTM for predicting trends...")
# Default parameters in HTM
default_parameters = {
# There are 2 (3) encoders: "value" (RDSE) & "time" (DateTime weekend, timeOfDay)
'enc': {
"value": {
'resolution': 0.88,
'size': 700,
'sparsity': 0.02
},
"time": {
'timeOfDay': (30, 1)
} #, 'weekend': 21}
},
'predictor': {
'sdrc_alpha': 0.1
},
'sp': {
'boostStrength': 3.0,
'columnCount': 1638,
'localAreaDensity': 0.04395604395604396,
'potentialPct': 0.85,
'synPermActiveInc': 0.04,
'synPermConnected': 0.13999999999999999,
'synPermInactiveDec': 0.006
},
'tm': {
'activationThreshold': 17,
'cellsPerColumn': 13,
'initialPerm': 0.21,
'maxSegmentsPerCell': 128,
'maxSynapsesPerSegment': 64,
'minThreshold': 10,
'newSynapseCount': 32,
'permanenceDec': 0.1,
'permanenceInc': 0.1
},
'anomaly': {
'likelihood': {
'probationaryPct': 0.1,
'reestimationPeriod': 100
}
}
}
# Make the encoder
print("- Make the encoder")
dateEncoder = DateEncoder(
timeOfDay=default_parameters["enc"]["time"]["timeOfDay"])
scalarEncoderParams = RDSE_Parameters()
scalarEncoderParams.size = default_parameters["enc"]["value"]["size"]
scalarEncoderParams.sparsity = default_parameters["enc"]["value"][
"sparsity"]
scalarEncoderParams.resolution = default_parameters["enc"]["value"][
"resolution"]
scalarEncoder = RDSE(scalarEncoderParams)
encodingWidth = (dateEncoder.size + scalarEncoder.size)
enc_info = Metrics([encodingWidth], 999999999)
# Make the SP
print("- Make the SP")
spParams = default_parameters["sp"]
sp = SpatialPooler(inputDimensions=(encodingWidth, ),
columnDimensions=(spParams["columnCount"], ),
potentialPct=spParams["potentialPct"],
potentialRadius=encodingWidth,
globalInhibition=True,
localAreaDensity=spParams["localAreaDensity"],
synPermInactiveDec=spParams["synPermInactiveDec"],
synPermActiveInc=spParams["synPermActiveInc"],
synPermConnected=spParams["synPermConnected"],
boostStrength=spParams["boostStrength"],
wrapAround=True)
sp_info = Metrics(sp.getColumnDimensions(), 999999999)
# Temporal Memory Parameters
print("- Make the TM")
tmParams = default_parameters["tm"]
tm = TemporalMemory(
columnDimensions=(spParams["columnCount"], ),
cellsPerColumn=tmParams["cellsPerColumn"],
activationThreshold=tmParams["activationThreshold"],
initialPermanence=tmParams["initialPerm"],
connectedPermanence=spParams["synPermConnected"],
minThreshold=tmParams["minThreshold"],
maxNewSynapseCount=tmParams["newSynapseCount"],
permanenceIncrement=tmParams["permanenceInc"],
permanenceDecrement=tmParams["permanenceDec"],
predictedSegmentDecrement=0.0,
maxSegmentsPerCell=tmParams["maxSegmentsPerCell"],
maxSynapsesPerSegment=tmParams["maxSynapsesPerSegment"])
tm_info = Metrics([tm.numberOfCells()], 999999999)
# Setup Likelihood
print("- Make Anomaly Score/Likelihood")
anParams = default_parameters["anomaly"]["likelihood"]
probationaryPeriod = int(
math.floor(float(anParams["probationaryPct"]) * len_data))
learningPeriod = int(math.floor(probationaryPeriod / 2.0))
anomaly_history = AnomalyLikelihood(
learningPeriod=learningPeriod,
estimationSamples=probationaryPeriod - learningPeriod,
reestimationPeriod=anParams["reestimationPeriod"])
# Make predictor
print("- Make the predictor")
predictor = Predictor(steps=[1, 5],
alpha=default_parameters["predictor"]['sdrc_alpha'])
predictor_resolution = 1
# End message
print("- Finish the building of HTM!")
def initialize(self, input_min=0, input_max=0):
# setup spatial anomaly
if self.useSpatialAnomaly:
self.spatial_tolerance = self.parameters["spatial_tolerance"]
## setup Enc, SP, TM
# Make the Encoders. These will convert input data into binary representations.
self.encTimestamp = DateEncoder(timeOfDay=self.parameters["enc"]["time"]["timeOfDay"])
scalarEncoderParams = RDSE_Parameters()
scalarEncoderParams.size = self.parameters["enc"]["value"]["size"]
scalarEncoderParams.activeBits = self.parameters["enc"]["value"]["activeBits"]
scalarEncoderParams.resolution = max(0.001, (input_max - input_min) / 130)
scalarEncoderParams.seed = self.parameters["enc"]["value"]["seed"]
self.encValue = RDSE(scalarEncoderParams)
encodingWidth = (self.encTimestamp.size + self.encValue.size)
self.enc_info = Metrics([encodingWidth], 999999999)
# Make the HTM. SpatialPooler & TemporalMemory & associated tools.
# SpatialPooler
spParams = self.parameters["sp"]
self.sp = SpatialPooler(
inputDimensions=(encodingWidth,),
columnDimensions=(spParams["columnDimensions"],),
potentialRadius=encodingWidth,
potentialPct=spParams["potentialPct"],
globalInhibition=spParams["globalInhibition"],
localAreaDensity=spParams["localAreaDensity"],
numActiveColumnsPerInhArea=spParams["numActiveColumnsPerInhArea"],
stimulusThreshold=spParams["stimulusThreshold"],
synPermInactiveDec=spParams["synPermInactiveDec"],
synPermActiveInc=spParams["synPermActiveInc"],
synPermConnected=spParams["synPermConnected"],
boostStrength=spParams["boostStrength"],
wrapAround=spParams["wrapAround"],
minPctOverlapDutyCycle=spParams["minPctOverlapDutyCycle"],
dutyCyclePeriod=spParams["dutyCyclePeriod"],
seed=spParams["seed"],
)
self.sp_info = Metrics(self.sp.getColumnDimensions(), 999999999)
# TemporalMemory
tmParams = self.parameters["tm"]
self.tm = TemporalMemory(
columnDimensions=(spParams["columnDimensions"],),
cellsPerColumn=tmParams["cellsPerColumn"],
activationThreshold=tmParams["activationThreshold"],
initialPermanence=tmParams["initialPermanence"],
connectedPermanence=tmParams["connectedPermanence"],
minThreshold=tmParams["minThreshold"],
maxNewSynapseCount=tmParams["maxNewSynapseCount"],
permanenceIncrement=tmParams["permanenceIncrement"],
permanenceDecrement=tmParams["permanenceDecrement"],
predictedSegmentDecrement=tmParams["predictedSegmentDecrement"],
maxSegmentsPerCell=tmParams["maxSegmentsPerCell"],
maxSynapsesPerSegment=tmParams["maxSynapsesPerSegment"],
seed=tmParams["seed"]
)
self.tm_info = Metrics([self.tm.numberOfCells()], 999999999)
anParams = self.parameters["anomaly"]["likelihood"]
self.learningPeriod = int(math.floor(self.probationaryPeriod / 2.0))
self.anomalyLikelihood = AnomalyLikelihood(
learningPeriod=self.learningPeriod,
estimationSamples=self.probationaryPeriod - self.learningPeriod,
reestimationPeriod=anParams["reestimationPeriod"])
self.kernel = self._gauss_kernel(self.historic_raw_anomaly_scores.maxlen,
self.historic_raw_anomaly_scores.maxlen)
def initialize(self):
# toggle parameters here
if self.use_optimization:
parameters = get_params('params.json')
else:
parameters = parameters_numenta_comparable
# setup spatial anomaly
if self.useSpatialAnomaly:
# Keep track of value range for spatial anomaly detection
self.minVal = None
self.maxVal = None
## setup Enc, SP, TM, Likelihood
# Make the Encoders. These will convert input data into binary representations.
self.encTimestamp = DateEncoder(timeOfDay= parameters["enc"]["time"]["timeOfDay"],
weekend = parameters["enc"]["time"]["weekend"])
scalarEncoderParams = RDSE_Parameters()
scalarEncoderParams.size = parameters["enc"]["value"]["size"]
scalarEncoderParams.sparsity = parameters["enc"]["value"]["sparsity"]
scalarEncoderParams.resolution = parameters["enc"]["value"]["resolution"]
self.encValue = RDSE( scalarEncoderParams )
encodingWidth = (self.encTimestamp.size + self.encValue.size)
self.enc_info = Metrics( [encodingWidth], 999999999 )
# Make the HTM. SpatialPooler & TemporalMemory & associated tools.
# SpatialPooler
spParams = parameters["sp"]
self.sp = SpatialPooler(
inputDimensions = (encodingWidth,),
columnDimensions = (spParams["columnCount"],),
potentialPct = spParams["potentialPct"],
potentialRadius = encodingWidth,
globalInhibition = True,
localAreaDensity = spParams["localAreaDensity"],
synPermInactiveDec = spParams["synPermInactiveDec"],
synPermActiveInc = spParams["synPermActiveInc"],
synPermConnected = spParams["synPermConnected"],
boostStrength = spParams["boostStrength"],
wrapAround = True
)
self.sp_info = Metrics( self.sp.getColumnDimensions(), 999999999 )
# TemporalMemory
tmParams = parameters["tm"]
self.tm = TemporalMemory(
columnDimensions = (spParams["columnCount"],),
cellsPerColumn = tmParams["cellsPerColumn"],
activationThreshold = tmParams["activationThreshold"],
initialPermanence = tmParams["initialPerm"],
connectedPermanence = spParams["synPermConnected"],
minThreshold = tmParams["minThreshold"],
maxNewSynapseCount = tmParams["newSynapseCount"],
permanenceIncrement = tmParams["permanenceInc"],
permanenceDecrement = tmParams["permanenceDec"],
predictedSegmentDecrement = 0.0,
maxSegmentsPerCell = tmParams["maxSegmentsPerCell"],
maxSynapsesPerSegment = tmParams["maxSynapsesPerSegment"]
)
self.tm_info = Metrics( [self.tm.numberOfCells()], 999999999 )
# setup likelihood, these settings are used in NAB
if self.useLikelihood:
anParams = parameters["anomaly"]["likelihood"]
learningPeriod = int(math.floor(self.probationaryPeriod / 2.0))
self.anomalyLikelihood = AnomalyLikelihood(
learningPeriod= learningPeriod,
estimationSamples= self.probationaryPeriod - learningPeriod,
reestimationPeriod= anParams["reestimationPeriod"])
# Predictor
# self.predictor = Predictor( steps=[1, 5], alpha=parameters["predictor"]['sdrc_alpha'] )
# predictor_resolution = 1
# initialize pandaBaker
if PANDA_VIS_BAKE_DATA:
self.BuildPandaSystem(self.sp, self.tm, parameters["enc"]["value"]["size"], self.encTimestamp.size)
def main(parameters=default_parameters, argv=None, verbose=True):
if verbose:
import pprint
print("Parameters:")
pprint.pprint(parameters, indent=4)
print("")
# Read the input file.
records = []
with open(_INPUT_FILE_PATH, "r") as fin:
reader = csv.reader(fin)
headers = next(reader)
next(reader)
next(reader)
for record in reader:
records.append(record)
# Make the Encoders. These will convert input data into binary representations.
dateEncoder = DateEncoder(timeOfDay= parameters["enc"]["time"]["timeOfDay"],
weekend = parameters["enc"]["time"]["weekend"])
scalarEncoderParams = RDSE_Parameters()
scalarEncoderParams.size = parameters["enc"]["value"]["size"]
scalarEncoderParams.sparsity = parameters["enc"]["value"]["sparsity"]
scalarEncoderParams.resolution = parameters["enc"]["value"]["resolution"]
scalarEncoder = RDSE( scalarEncoderParams )
encodingWidth = (dateEncoder.size + scalarEncoder.size)
enc_info = Metrics( [encodingWidth], 999999999 )
# Make the HTM. SpatialPooler & TemporalMemory & associated tools.
spParams = parameters["sp"]
sp = SpatialPooler(
inputDimensions = (encodingWidth,),
columnDimensions = (spParams["columnCount"],),
potentialPct = spParams["potentialPct"],
potentialRadius = encodingWidth,
globalInhibition = True,
localAreaDensity = spParams["localAreaDensity"],
synPermInactiveDec = spParams["synPermInactiveDec"],
synPermActiveInc = spParams["synPermActiveInc"],
synPermConnected = spParams["synPermConnected"],
boostStrength = spParams["boostStrength"],
wrapAround = True
)
sp_info = Metrics( sp.getColumnDimensions(), 999999999 )
tmParams = parameters["tm"]
tm = TemporalMemory(
columnDimensions = (spParams["columnCount"],),
cellsPerColumn = tmParams["cellsPerColumn"],
activationThreshold = tmParams["activationThreshold"],
initialPermanence = tmParams["initialPerm"],
connectedPermanence = spParams["synPermConnected"],
minThreshold = tmParams["minThreshold"],
maxNewSynapseCount = tmParams["newSynapseCount"],
permanenceIncrement = tmParams["permanenceInc"],
permanenceDecrement = tmParams["permanenceDec"],
predictedSegmentDecrement = 0.0,
maxSegmentsPerCell = tmParams["maxSegmentsPerCell"],
maxSynapsesPerSegment = tmParams["maxSynapsesPerSegment"]
)
tm_info = Metrics( [tm.numberOfCells()], 999999999 )
# setup likelihood, these settings are used in NAB
anParams = parameters["anomaly"]["likelihood"]
probationaryPeriod = int(math.floor(float(anParams["probationaryPct"])*len(records)))
learningPeriod = int(math.floor(probationaryPeriod / 2.0))
anomaly_history = AnomalyLikelihood(learningPeriod= learningPeriod,
estimationSamples= probationaryPeriod - learningPeriod,
reestimationPeriod= anParams["reestimationPeriod"])
predictor = Predictor( steps=[1, 5], alpha=parameters["predictor"]['sdrc_alpha'] )
predictor_resolution = 1
# Iterate through every datum in the dataset, record the inputs & outputs.
inputs = []
anomaly = []
anomalyProb = []
predictions = {1: [], 5: []}
for count, record in enumerate(records):
# Convert date string into Python date object.
dateString = datetime.datetime.strptime(record[0], "%m/%d/%y %H:%M")
# Convert data value string into float.
consumption = float(record[1])
inputs.append( consumption )
# Call the encoders to create bit representations for each value. These are SDR objects.
dateBits = dateEncoder.encode(dateString)
consumptionBits = scalarEncoder.encode(consumption)
# Concatenate all these encodings into one large encoding for Spatial Pooling.
encoding = SDR( encodingWidth ).concatenate([consumptionBits, dateBits])
enc_info.addData( encoding )
# Create an SDR to represent active columns, This will be populated by the
# compute method below. It must have the same dimensions as the Spatial Pooler.
activeColumns = SDR( sp.getColumnDimensions() )
# Execute Spatial Pooling algorithm over input space.
sp.compute(encoding, True, activeColumns)
sp_info.addData( activeColumns )
# Execute Temporal Memory algorithm over active mini-columns.
tm.compute(activeColumns, learn=True)
tm_info.addData( tm.getActiveCells().flatten() )
# Predict what will happen, and then train the predictor based on what just happened.
pdf = predictor.infer( count, tm.getActiveCells() )
for n in (1, 5):
if pdf[n]:
predictions[n].append( np.argmax( pdf[n] ) * predictor_resolution )
else:
predictions[n].append(float('nan'))
predictor.learn( count, tm.getActiveCells(), int(consumption / predictor_resolution))
anomalyLikelihood = anomaly_history.anomalyProbability( consumption, tm.anomaly )
anomaly.append( tm.anomaly )
anomalyProb.append( anomalyLikelihood )
# Print information & statistics about the state of the HTM.
print("Encoded Input", enc_info)
print("")
print("Spatial Pooler Mini-Columns", sp_info)
print(str(sp))
print("")
print("Temporal Memory Cells", tm_info)
print(str(tm))
print("")
# Shift the predictions so that they are aligned with the input they predict.
for n_steps, pred_list in predictions.items():
for x in range(n_steps):
pred_list.insert(0, float('nan'))
pred_list.pop()
# Calculate the predictive accuracy, Root-Mean-Squared
accuracy = {1: 0, 5: 0}
accuracy_samples = {1: 0, 5: 0}
for idx, inp in enumerate(inputs):
for n in predictions: # For each [N]umber of time steps ahead which was predicted.
val = predictions[n][ idx ]
if not math.isnan(val):
accuracy[n] += (inp - val) ** 2
accuracy_samples[n] += 1
for n in sorted(predictions):
accuracy[n] = (accuracy[n] / accuracy_samples[n]) ** .5
print("Predictive Error (RMS)", n, "steps ahead:", accuracy[n])
# Show info about the anomaly (mean & std)
print("Anomaly Mean", np.mean(anomaly))
print("Anomaly Std ", np.std(anomaly))
# Plot the Predictions and Anomalies.
if verbose:
try:
import matplotlib.pyplot as plt
except:
print("WARNING: failed to import matplotlib, plots cannot be shown.")
return -accuracy[5]
plt.subplot(2,1,1)
plt.title("Predictions")
plt.xlabel("Time")
plt.ylabel("Power Consumption")
plt.plot(np.arange(len(inputs)), inputs, 'red',
np.arange(len(inputs)), predictions[1], 'blue',
np.arange(len(inputs)), predictions[5], 'green',)
plt.legend(labels=('Input', '1 Step Prediction, Shifted 1 step', '5 Step Prediction, Shifted 5 steps'))
plt.subplot(2,1,2)
plt.title("Anomaly Score")
plt.xlabel("Time")
plt.ylabel("Power Consumption")
inputs = np.array(inputs) / max(inputs)
plt.plot(np.arange(len(inputs)), inputs, 'red',
np.arange(len(inputs)), anomaly, 'blue',)
plt.legend(labels=('Input', 'Anomaly Score'))
plt.show()
return -accuracy[5]
import warnings
from htm.bindings.sdr import SDR, Metrics
from htm.encoders.rdse import RDSE, RDSE_Parameters
from htm.encoders.date import DateEncoder
from htm.bindings.algorithms import SpatialPooler
from htm.bindings.algorithms import TemporalMemory
from htm.algorithms.anomaly_likelihood import AnomalyLikelihood
from htm.bindings.algorithms import Predictor
import matplotlib
import matplotlib.pyplot as plt
dateEncoder = DateEncoder(timeOfDay=(30, 1), weekend=21)
scalarEncoderParams = RDSE_Parameters()
scalarEncoderParams.size = 700
scalarEncoderParams.sparsity = 0.02
scalarEncoderParams.resolution = 0.88
scalarEncoder = RDSE(scalarEncoderParams)
encodingWidth = (dateEncoder.size + scalarEncoder.size)
sp = SpatialPooler(inputDimensions=(encodingWidth, ),
columnDimensions=(1638, ),
potentialPct=0.85,
potentialRadius=encodingWidth,
globalInhibition=True,
localAreaDensity=0.04395604395604396,
synPermInactiveDec=0.006,
synPermActiveInc=0.04,
synPermConnected=0.13999999999999999,
def initialize(self):
# toggle parameters here
# parameters = default_parameters
parameters = parameters_numenta_comparable
## setup Enc, SP, TM, Likelihood
# Make the Encoders. These will convert input data into binary representations.
self.encTimestamp = DateEncoder(
timeOfDay=parameters["enc"]["time"]["timeOfDay"],
weekend=parameters["enc"]["time"]["weekend"],
season=parameters["enc"]["time"]["season"],
dayOfWeek=parameters["enc"]["time"]["dayOfWeek"])
scalarEncoderParams = EncParameters()
scalarEncoderParams.size = parameters["enc"]["value"]["size"]
scalarEncoderParams.sparsity = parameters["enc"]["value"]["sparsity"]
scalarEncoderParams.resolution = parameters["enc"]["value"][
"resolution"]
self.encValue = Encoder(scalarEncoderParams)
encodingWidth = (self.encTimestamp.size + self.encValue.size)
self.enc_info = Metrics([encodingWidth], 999999999)
# Make the HTM. SpatialPooler & TemporalMemory & associated tools.
# SpatialPooler
spParams = parameters["sp"]
self.sp = SpatialPooler(
inputDimensions=(encodingWidth, ),
columnDimensions=(spParams["columnCount"], ),
potentialPct=spParams["potentialPct"],
potentialRadius=spParams["potentialRadius"],
globalInhibition=True,
localAreaDensity=spParams["localAreaDensity"],
stimulusThreshold=spParams["stimulusThreshold"],
synPermInactiveDec=spParams["synPermInactiveDec"],
synPermActiveInc=spParams["synPermActiveInc"],
synPermConnected=spParams["synPermConnected"],
boostStrength=spParams["boostStrength"],
wrapAround=True)
self.sp_info = Metrics(self.sp.getColumnDimensions(), 999999999)
# TemporalMemory
tmParams = parameters["tm"]
self.tm = TemporalMemory(
columnDimensions=(spParams["columnCount"], ),
cellsPerColumn=tmParams["cellsPerColumn"],
activationThreshold=tmParams["activationThreshold"],
initialPermanence=tmParams["initialPerm"],
connectedPermanence=spParams["synPermConnected"],
minThreshold=tmParams["minThreshold"],
maxNewSynapseCount=tmParams["newSynapseCount"],
permanenceIncrement=tmParams["permanenceInc"],
permanenceDecrement=tmParams["permanenceDec"],
predictedSegmentDecrement=0.0,
maxSegmentsPerCell=tmParams["maxSegmentsPerCell"],
maxSynapsesPerSegment=tmParams["maxSynapsesPerSegment"])
self.tm_info = Metrics([self.tm.numberOfCells()], 999999999)
# setup likelihood, these settings are used in NAB
if self.useLikelihood:
anParams = parameters["anomaly"]["likelihood"]
learningPeriod = int(math.floor(self.probationaryPeriod / 2.0))
self.anomalyLikelihood = AnomalyLikelihood(
learningPeriod=learningPeriod,
estimationSamples=self.probationaryPeriod - learningPeriod,
reestimationPeriod=anParams["reestimationPeriod"])