def __init__(
self,
configs=(), # block configuration
num_l=2, # number of labels
min_val=0.0, # minimum input value
max_val=1.0, # maximum input value
num_i=1024, # number of input statelets
num_ai=128, # number of active input statelets
num_s=512, # number of statelets
num_as=8, # number of active statelets
pct_pool=0.8, # pooling percentage
pct_conn=0.5, # initially connected percentage
pct_learn=0.3): # learn percentage
PERM_THR = 20
PERM_INC = 2
PERM_DEC = 1
# seed the random number generator
# bb.seed(0) # TODO: fix seeding
self.st = ScalarTransformer(min_val, max_val, num_i, num_ai)
self.pc = PatternClassifier(num_l, num_s, num_as, PERM_THR, PERM_INC,
PERM_DEC, pct_pool, pct_conn, pct_learn)
self.pc.input.add_child(self.st.output, 0)
self.pc.init()
def __init__(
self,
min_val=0.0, # minimum input value
max_val=1.0, # maximum input value
max_step=8, # maximum persistence step
num_i=1024, # number of input statelets
num_ai=128, # number of active input statelets
num_s=512, # number of statelets
num_as=8, # number of active statelets
num_spc=10, # number of statelets per column
num_dps=10, # number of dendrites per statelet
num_rpd=12, # number of receptors per dendrite
d_thresh=6, # dendrite threshold
pct_pool=0.8, # pooling percentage
pct_conn=0.5, # initially connected percentage
pct_learn=0.3): # learn percentage
PERM_THR = 20
PERM_INC = 2
PERM_DEC = 1
num_i_half = int(num_i / 2)
num_ai_half = int(num_ai / 2)
self.min_val = min_val
self.max_val = max_val
# seed the random number generator
#bb.seed(0) # TODO: fix seeding
self.st = ScalarTransformer(min_val, max_val, num_i_half, num_ai_half)
self.pt = PersistenceTransformer(min_val, max_val, num_i_half,
num_ai_half, max_step)
self.pp = PatternPooler(num_s, num_as, PERM_THR, PERM_INC, PERM_DEC,
pct_pool, pct_conn, pct_learn)
self.sl = SequenceLearner(num_s, num_spc, num_dps, num_rpd, d_thresh,
PERM_THR, PERM_INC, PERM_DEC)
self.pp.input.add_child(self.st.output, 0)
self.pp.input.add_child(self.pt.output, 0)
self.sl.input.add_child(self.pp.output, 0)
self.pp.init()
self.sl.init()
class Classifier():
def __init__(
self,
configs=(), # block configuration
num_l=2, # number of labels
min_val=0.0, # minimum input value
max_val=1.0, # maximum input value
num_i=1024, # number of input statelets
num_ai=128, # number of active input statelets
num_s=512, # number of statelets
num_as=8, # number of active statelets
pct_pool=0.8, # pooling percentage
pct_conn=0.5, # initially connected percentage
pct_learn=0.3): # learn percentage
PERM_THR = 20
PERM_INC = 2
PERM_DEC = 1
# seed the random number generator
# bb.seed(0) # TODO: fix seeding
self.st = ScalarTransformer(min_val, max_val, num_i, num_ai)
self.pc = PatternClassifier(num_l, num_s, num_as, PERM_THR, PERM_INC,
PERM_DEC, pct_pool, pct_conn, pct_learn)
self.pc.input.add_child(self.st.output, 0)
self.pc.init()
#def save(self, path='./', name='classifier'):
# self.pc.save(path + name + "_pc.bin")
#def load(self, path='./', name='classifier'):
# self.pc.load(path + name + "_pc.bin")
def fit(self, value=0.0, label=0):
self.st.set_value(value)
self.pc.set_label(label)
self.st.feedforward()
self.pc.feedforward(learn=True)
return self.pc.get_probabilities()
def predict(self, value=0.0):
self.st.set_value(value)
self.st.feedforward()
self.pc.feedforward(learn=False)
return self.pc.get_probabilities()
def get_scalability(num_detectors):
process = psutil.Process(os.getpid())
scores = []
# Setup Blocks
transformers = []
pattern_poolers = []
sequence_learners = []
for _ in range(num_detectors):
transformers.append(
ScalarTransformer(min_val=0.0, max_val=1.0, num_s=1024,
num_as=128))
pattern_poolers.append(
PatternPooler(num_s=512,
num_as=8,
pct_pool=0.8,
pct_conn=0.5,
pct_learn=0.3))
sequence_learners.append(
SequenceLearner(num_c=512,
num_spc=10,
num_dps=10,
num_rpd=12,
d_thresh=6))
pattern_poolers[-1].input.add_child(transformers[-1].output, 0)
sequence_learners[-1].input.add_child(pattern_poolers[-1].output, 0)
# Get initialization time and memory usage
t0 = time.time()
for d in range(num_detectors):
pattern_poolers[d].init()
sequence_learners[d].init()
t1 = time.time()
init_time = t1 - t0
num_bytes = process.memory_info().rss
# Get compute time
t0 = time.time()
for d in range(num_detectors):
for i in range(len(data)):
transformers[d].set_value(data[i])
transformers[d].feedforward()
pattern_poolers[d].feedforward(learn=True)
sequence_learners[d].feedforward(learn=True)
if (d == 0):
score = sequence_learners[d].get_anomaly_score()
scores.append(score)
t1 = time.time()
comp_time = t1 - t0
# Test Results
np.testing.assert_array_equal(np.array(scores), expected_scores)
return [num_detectors, num_bytes, init_time, comp_time]
# Printing boolean arrays neatly
np.set_printoptions(
precision=3,
suppress=True,
threshold=1000000,
linewidth=80,
formatter={"bool": lambda bin_val: "X" if bin_val else "-"})
values = [
0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0,
1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0
]
st = ScalarTransformer(
min_val=0.0, # minimum input value
max_val=1.0, # maximum input value
num_s=1024, # number of statelets
num_as=128) # number of active statelets
# Convert scalars to distributed binary representation
for i in range(len(values)):
# Set scalar transformer value
st.set_value(values[i])
# Compute scalar transformer
st.feedforward()
# List of 0s and 1s representing the distributed binary representation
intarray = st.output.bits
class AnomalyDetectorPersist():
def __init__(
self,
min_val=0.0, # minimum input value
max_val=1.0, # maximum input value
max_step=8, # maximum persistence step
num_i=1024, # number of input statelets
num_ai=128, # number of active input statelets
num_s=512, # number of statelets
num_as=8, # number of active statelets
num_spc=10, # number of statelets per column
num_dps=10, # number of dendrites per statelet
num_rpd=12, # number of receptors per dendrite
d_thresh=6, # dendrite threshold
pct_pool=0.8, # pooling percentage
pct_conn=0.5, # initially connected percentage
pct_learn=0.3): # learn percentage
PERM_THR = 20
PERM_INC = 2
PERM_DEC = 1
num_i_half = int(num_i / 2)
num_ai_half = int(num_ai / 2)
self.min_val = min_val
self.max_val = max_val
# seed the random number generator
#bb.seed(0) # TODO: fix seeding
self.st = ScalarTransformer(min_val, max_val, num_i_half, num_ai_half)
self.pt = PersistenceTransformer(min_val, max_val, num_i_half,
num_ai_half, max_step)
self.pp = PatternPooler(num_s, num_as, PERM_THR, PERM_INC, PERM_DEC,
pct_pool, pct_conn, pct_learn)
self.sl = SequenceLearner(num_s, num_spc, num_dps, num_rpd, d_thresh,
PERM_THR, PERM_INC, PERM_DEC)
self.pp.input.add_child(self.st.output, 0)
self.pp.input.add_child(self.pt.output, 0)
self.sl.input.add_child(self.pp.output, 0)
self.pp.init()
self.sl.init()
#def save(self, path='./', name='detector'):
# self.pp.save(path + name + "_pp.bin")
# self.sl.save(path + name + "_sl.bin")
#def load(self, path='./', name='detector'):
# self.pp.load(path + name + "_pp.bin")
# self.sl.load(path + name + "_sl.bin")
def feedforward(self, value=0.0, learn=True):
in_bounds = True
if value < self.min_val or value > self.max_val:
in_bounds = False
self.st.set_value(value)
self.pt.set_value(value)
self.st.feedforward()
self.pt.feedforward()
self.pp.feedforward(learn)
self.sl.feedforward(learn)
#print(self.pp.input.acts)
#print(self.pt.output.acts)
#print()
if in_bounds:
anom = self.sl.get_anomaly_score()
else:
anom = 1.0
return anom
values0 = [
0.0, 0.2, 0.4, 0.6, 0.8, 0.0, 0.2, 0.4, 0.6, 0.8, 0.0, 0.2, 0.4, 0.6, 0.8,
0.0, 0.2, 0.4, 0.6, 0.8
]
values1 = [
0.0, 0.2, 0.4, 0.6, 0.8, 0.8, 0.6, 0.4, 0.2, 0.0, 0.0, 0.2, 0.4, 0.6, 0.8,
0.8, 0.6, 0.4, 0.2, 0.0
]
scores0 = [0 for i in range(num_values)]
scores1 = [0 for i in range(num_values)]
scores2 = [0 for i in range(num_values)]
# Setup blocks
st0 = ScalarTransformer(num_s=500, num_as=50)
st1 = ScalarTransformer(num_s=500, num_as=50)
pp0 = PatternPooler(num_s=250, num_as=8)
pp1 = PatternPooler(num_s=250, num_as=8)
pp2 = PatternPooler(num_s=250, num_as=8)
sl0 = SequenceLearner()
sl1 = SequenceLearner()
sl2 = SequenceLearner()
# Connect blocks
pp0.input.add_child(st0.output, 0)
pp1.input.add_child(st1.output, 0)
pp2.input.add_child(pp0.output, 0)
pp2.input.add_child(pp1.output, 0)
sl0.input.add_child(pp0.output, 0)
sl1.input.add_child(pp1.output, 0)