def test_sequence_learner(): e = ScalarEncoder(min_val=0.0, max_val=1.0, num_s=64, num_as=8) sl = SequenceLearner(num_spc=10, num_dps=10, num_rpd=12, d_thresh=6, perm_thr=1, perm_inc=1, perm_dec=0) sl.input.add_child(e.output) data = [ 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] expect_scores = np.array([ 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ]) actual_scores = np.array([0.0 for i in range(len(data))]) for i in range(len(data)): e.compute(data[i]) sl.compute(True) actual_scores[i] = sl.get_score() np.testing.assert_array_equal(actual_scores, expect_scores)
def __init__( self, configs=(), # block configuration labels=(0, 1), # labels min_val=-1.0, # ScalarEncoder minimum input value max_val=1.0, # ScalarEncoder maximum input value num_i=1024, # ScalarEncoder number of statelets num_ai=128, # ScalarEncoder number of active statelets num_s=32, # PatternClassifier number of statelets num_as=8, # PatternClassifier number of active statelets pct_pool=0.8, # PatternClassifier pool percentage pct_conn=0.5, # PatternClassifier initial connection percentage pct_learn=0.25): # PatternClassifier learn percentage # seed the random number generator bb.seed(0) # build blocks from config descriptions if given blocks = get_blocks(configs) self.encoders = blocks["encoders"] self.pc = blocks["pattern_classifier"] if len(self.encoders) == 0: self.encoders.append(ScalarEncoder(min_val, max_val, num_i, num_ai)) if self.pc == None: num_l = len(labels) self.pc = PatternClassifier(labels, num_s, num_as, 20, 2, 1, pct_pool, pct_conn, pct_learn) for encoder in self.encoders: self.pc.input.add_child(encoder.output)
def get_scalability(num_detectors): process = psutil.Process(os.getpid()) scores = [] # Setup Blocks encoders = [] pattern_poolers = [] sequence_learners = [] for _ in range(num_detectors): encoders.append( ScalarEncoder(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.8, pct_learn=0.25)) sequence_learners.append( SequenceLearner(num_spc=10, num_dps=10, num_rpd=12, d_thresh=6)) pattern_poolers[-1].input.add_child(encoders[-1].output) sequence_learners[-1].input.add_child(pattern_poolers[-1].output) # Get initialization time and memory usage t0 = time.time() for d in range(num_detectors): encoders[d].compute(data[0]) pattern_poolers[d].compute(learn=True) sequence_learners[d].compute(learn=True) if (d == 0): score = sequence_learners[d].get_score() scores.append(score) 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(1, len(data)): encoders[d].compute(data[i]) pattern_poolers[d].compute(learn=True) sequence_learners[d].compute(learn=True) if (d == 0): score = sequence_learners[d].get_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]
def test_sequence_learner_sine(): e = ScalarEncoder( min_val=0.0, # minimum input value max_val=1.0, # maximum input value num_s=64, # number of statelets num_as=8) # number of active statelets sl = SequenceLearner( num_spc=10, # number of statelets per column num_dps=10, # number of coincidence detectors per statelet num_rpd=24, # number of receptors per coincidence detector d_thresh=6, # coincidence detector threshold perm_thr=1, # receptor permanence threshold perm_inc=1, # receptor permanence increment perm_dec=0) # receptor permanence decrement sl.input.add_child(e.output) values = [ 0.50, 0.79, 0.98, 0.98, 0.79, 0.50, 0.21, 0.02, 0.02, 0.21, 0.50, 0.79, 0.98, 0.98, 0.79, 0.50, 0.21, 0.02, 0.02, 0.21, 0.50, 0.79, 0.98, 0.98, 0.79, 0.50, 0.21, 0.02, 0.02, 0.21 ] actual_scores = np.array([0.0 for i in range(len(values))]) expect_scores = np.array([ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ]) for i in range(len(values)): e.compute(value=values[i]) sl.compute(learn=True) actual_scores[i] = sl.get_score() np.testing.assert_array_equal(actual_scores, expect_scores)
def test_read_coincidence_set(): e = ScalarEncoder() pp = PatternPooler() pp.input.add_child(e.output) pp.initialize() cs = pp.coincidence_sets(0) addrs = cs.get_addrs() addr0 = cs.get_addr(0) np.testing.assert_equal(addrs[0], addr0) perms = cs.get_perms() perm0 = cs.get_perm(0) np.testing.assert_equal(perms[0], perm0)
def test_read_indicator(): e = ScalarEncoder(min_val=-1.0, max_val=1.0, num_s=128, num_as=16) pp = PatternPooler(num_s=128, num_as=2) pp.input.add_child(e.output) pp.initialize() cs = pp.coincidence_sets(0) addrs = cs.get_addrs() addr0 = cs.get_addr(0) np.testing.assert_equal(addrs[0], addr0) perms = cs.get_perms() perm0 = cs.get_perm(0) np.testing.assert_equal(perms[0], perm0)
def __init__( self, configs=(), # block configuration min_val=-1.0, # minumum value max_val=1.0, # maximum value num_i=1024, # ScalarEncoder number of statelets num_ai=128, # ScalarEncoder number of active statelets num_s=512, # PatternPooler number of statelets num_as=8, # PatternPooler number of active statelets num_spc=10, # SequenceLearner number of statelets per column num_dps=10, # SequenceLearner number of coincidence detectors per statelet num_rpd=12, # SequenceLearner number of receptors per coincidence detector d_thresh=6, # SequenceLearner coincidence detector threshold pct_pool=0.8, # PatternPooler pool percentage pct_conn=0.5, # PatternPooler initial connection percentage pct_learn=0.25): # PatternPooler learn percentage self.min_val = min_val self.max_val = max_val # seed the random number generator bb.seed(0) # build blocks from config descriptions if given blocks = get_blocks(configs) self.encoders = blocks["encoders"] self.pp = blocks["pattern_pooler"] self.sl = blocks["sequence_learner"] if len(self.encoders) == 0: self.encoders.append(ScalarEncoder(min_val, max_val, num_i, num_ai)) if self.pp == None: self.pp = PatternPooler(num_s, num_as, 20, 2, 1, pct_pool, pct_conn, pct_learn) if self.sl == None: self.sl = SequenceLearner(num_spc, num_dps, num_rpd, d_thresh, 1, 1, 0) for encoder in self.encoders: self.pp.input.add_child(encoder.output) self.sl.input.add_child(self.pp.output) self.initialized = False
0.0, 0.0, 0.0, 0.0, ] labels = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 ] new_label = 0 scores = [0.0 for i in range(len(values))] e = ScalarEncoder( min_val=0.0, # minimum input value max_val=1.0, # maximum input value num_s=64, # number of statelets num_as=8) # number of active statelets sl = SequenceLearner( num_spc=10, # number of statelets per column num_dps=10, # number of coincidence detectors per statelet num_rpd=12, # number of receptors per coincidence detector d_thresh=6, # coincidence detector threshold perm_thr=1, # receptor permanence threshold perm_inc=1, # receptor permanence increment perm_dec=0) # receptor permanence decrement pc = PatternClassifier( labels=labels, # user-defined labels num_s=640, # number of statelets
from brainblocks.blocks import ScalarEncoder, PatternPooler, SequenceLearner # define data and scores num_inputs = 20 inputs_0 = [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] inputs_1 = [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] scores_0 = [0 for i in range(num_inputs)] scores_1 = [0 for i in range(num_inputs)] scores_2 = [0 for i in range(num_inputs)] # define blocks se_0 = ScalarEncoder(num_s=500, num_as=50) se_1 = ScalarEncoder(num_s=500, num_as=50) pp_0 = PatternPooler(num_s=250, num_as=8) pp_1 = PatternPooler(num_s=250, num_as=8) pp_2 = PatternPooler(num_s=250, num_as=8) sl_0 = SequenceLearner() sl_1 = SequenceLearner() sl_2 = SequenceLearner() # connect blocks pp_0.input.add_child(se_0.output) pp_1.input.add_child(se_1.output) pp_2.input.add_child(pp_0.output) pp_2.input.add_child(pp_1.output) sl_0.input.add_child(pp_0.output) sl_1.input.add_child(pp_1.output) sl_2.input.add_child(pp_2.output) # loop through data for i in range(num_inputs):
# printing boolean arrays neatly np.set_printoptions( precision=3, suppress=True, threshold=1000000, linewidth=100, 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, 0.0, 1.0, 0.0, 1.0, 0.0 ] se_0 = ScalarEncoder(num_s=1024, num_as=128) # convert scalars to distributed binary representation for i in range(len(values)): # encode scalars se_0.compute(values[i]) # list of 0s and 1s representing the distributed binary representation intarray = se_0.output.bits # converted to numpy array for visualization binary_array = np.array(intarray, dtype=np.bool) print(values[i]) print(binary_array)
def test_scalar_encoder(): e = ScalarEncoder( min_val=-1.0, # minimum input value max_val=1.0, # maximum input value num_s=1024, # number of statelets num_as=128) # number of active statelets e.compute(value=-1.5) actual_out = np.array(e.output.bits) expect_out = np.array([0 for i in range(1024)]) expect_out[0:128] = 1 np.testing.assert_array_equal(actual_out, expect_out) e.compute(value=-1.0) actual_out = np.array(e.output.bits) expect_out = np.array([0 for i in range(1024)]) expect_out[0:128] = 1 np.testing.assert_array_equal(actual_out, expect_out) e.compute(value=-0.5) actual_out = np.array(e.output.bits) expect_out = np.array([0 for i in range(1024)]) expect_out[224:352] = 1 np.testing.assert_array_equal(actual_out, expect_out) e.compute(value=0.0) actual_out = np.array(e.output.bits) expect_out = np.array([0 for i in range(1024)]) expect_out[448:576] = 1 np.testing.assert_array_equal(actual_out, expect_out) e.compute(value=0.5) actual_out = np.array(e.output.bits) expect_out = np.array([0 for i in range(1024)]) expect_out[672:800] = 1 np.testing.assert_array_equal(actual_out, expect_out) e.compute(value=1.0) actual_out = np.array(e.output.bits) expect_out = np.array([0 for i in range(1024)]) expect_out[896:1024] = 1 np.testing.assert_array_equal(actual_out, expect_out) e.compute(value=1.5) actual_out = np.array(e.output.bits) expect_out = np.array([0 for i in range(1024)]) expect_out[896:1024] = 1 np.testing.assert_array_equal(actual_out, expect_out)
] x_tests = [0.0, 1.0] # string symbols converted to integers le = preprocessing.LabelEncoder() le.fit(y_trains) y_trains_ints = le.transform(y_trains) # retrieve the integer classes from above int_classes = [k for k in range(len(le.classes_))] # define blocks se = ScalarEncoder( min_val=-1.0, # minimum input value max_val=1.0, # maximum input value num_s=1024, # number of statelets num_as=128) # number of active statelets pp = PatternClassifier( labels=int_classes, # user-defined labels num_s=512, # number of statelets num_as=8, # number of active statelets perm_thr=20, # receptor permanence threshold perm_inc=2, # receptor permanence increment perm_dec=1, # receptor permanence decrement pct_pool=0.8, # pooling percentage pct_conn=0.5, # initially connected percentage pct_learn=0.25) # learn percentage # connect blocks
def test_scalar_encoder(): e = ScalarEncoder(min_val=-1.0, max_val=1.0, num_s=1024, num_as=128) e.compute(-1.5) actual_out = np.array(e.output.get_bits(0)) expect_out = np.array([0 for i in range(1024)]) expect_out[0:128] = 1 np.testing.assert_array_equal(actual_out, expect_out) e.compute(-1.0) actual_out = np.array(e.output.get_bits(0)) expect_out = np.array([0 for i in range(1024)]) expect_out[0:128] = 1 np.testing.assert_array_equal(actual_out, expect_out) e.compute(-0.5) actual_out = np.array(e.output.get_bits(0)) expect_out = np.array([0 for i in range(1024)]) expect_out[224:352] = 1 np.testing.assert_array_equal(actual_out, expect_out) e.compute(0.0) actual_out = np.array(e.output.get_bits(0)) expect_out = np.array([0 for i in range(1024)]) expect_out[448:576] = 1 np.testing.assert_array_equal(actual_out, expect_out) e.compute(0.5) actual_out = np.array(e.output.get_bits(0)) expect_out = np.array([0 for i in range(1024)]) expect_out[672:800] = 1 np.testing.assert_array_equal(actual_out, expect_out) e.compute(1.0) actual_out = np.array(e.output.get_bits(0)) expect_out = np.array([0 for i in range(1024)]) expect_out[896:1024] = 1 np.testing.assert_array_equal(actual_out, expect_out) e.compute(1.5) actual_out = np.array(e.output.get_bits(0)) expect_out = np.array([0 for i in range(1024)]) expect_out[896:1024] = 1 np.testing.assert_array_equal(actual_out, expect_out)
from etaler import et from brainblocks.blocks import ScalarEncoder se_0 = ScalarEncoder(num_s=1024, num_as=128) se_0.compute(0) a = et.Tensor.from_numpy(se_0.output.bits) print(a.tolist()) print(a.to_brainblocks())