def setUp(self):
self.minicolumn = Minicolumn(
space_size=5,
in_random_bits=1,
out_random_bits=1,
in_dimensions=1,
out_dimensions=1,
code_alignment=1,
in_code_activate=0,
class_point=PointNoneMock
)
self.minicolumn_zeros = Minicolumn(
space_size=5,
in_random_bits=3,
out_random_bits=3,
in_dimensions=3,
out_dimensions=3,
code_alignment=2,
seed=42,
in_code_activate=0,
class_point=PointZerosMock
)
self.minicolumn_controversy_out = Minicolumn(
space_size=5,
in_random_bits=4,
out_random_bits=8,
in_dimensions=4,
out_dimensions=8,
code_alignment=4,
seed=42,
controversy=2,
class_point=PointEmptyMock
)
self.minicolumn_controversy_in = Minicolumn(
space_size=200,
in_random_bits=4,
out_random_bits=8,
in_dimensions=4,
out_dimensions=8,
code_alignment=2,
seed=42,
controversy=0.2,
in_code_activate=0,
class_point=PointControversyInMock
)
self.minicolumn_code_alignment = Minicolumn(
space_size=5,
in_random_bits=4,
out_random_bits=8,
in_dimensions=4,
out_dimensions=8,
code_alignment=4,
seed=42,
controversy=0.1,
in_code_activate=0,
min_active_points=0,
class_point=PointCodeAligmentMock
)
def setUp(self):
self.minicolumn = Minicolumn(
space_size=5,
in_random_bits=1,
out_random_bits=1,
in_dimensions=1,
out_dimensions=1,
code_alignment=1,
class_point=PointNoneMock
)
def setUp(self):
self.minicolumn_none = Minicolumn(
space_size=100,
in_random_bits=1,
out_random_bits=1,
in_dimensions=1,
out_dimensions=1,
code_alignment=1,
class_point=PointNoneMock
)
self.minicolumn = Minicolumn(
space_size=20,
in_random_bits=10,
out_random_bits=10,
in_dimensions=10,
out_dimensions=10,
seed=41,
controversy=0.05,
code_alignment=1,
min_active_points=0,
class_point=PointOddEvenMock
)
self.minicolumn_front = Minicolumn(
space_size=20,
in_random_bits=10,
out_random_bits=2,
in_dimensions=10,
out_dimensions=2,
seed=41,
controversy=0.05,
code_alignment=1,
class_point=PointEmptyMock
)
self.minicolumn_back = Minicolumn(
space_size=20,
in_random_bits=2,
out_random_bits=10,
in_dimensions=2,
out_dimensions=10,
seed=41,
controversy=0.05,
code_alignment=1,
class_point=PointEmptyMock
)
self.minicolumn_assert_dim_2 = Minicolumn(
space_size=20,
in_random_bits=2,
out_random_bits=10,
in_dimensions=2,
out_dimensions=10,
seed=41,
controversy=0.05,
code_alignment=1,
class_point=PointEmptyMock
)
def test_code_alignment(self):
self.assertRaises(ValueError, Minicolumn, code_alignment=-5)
self.assertRaises(ValueError, Minicolumn, code_alignment=None)
self.assertRaises(
ValueError, Minicolumn,
code_alignment=3, in_dimensions=4, out_dimensions=2,
in_random_bits=1, out_random_bits=1
)
self.assertRaises(
ValueError, Minicolumn,
code_alignment=3, in_dimensions=3, out_dimensions=2,
in_random_bits=1, out_random_bits=1
)
Minicolumn(
space_size=10,
code_alignment=2, in_dimensions=4, out_dimensions=4,
in_random_bits=1, out_random_bits=1
)
the_same_clusters)
df = pd.read_csv('data/MNIST/mnist_train.csv', header=None, nrows=100)
max_number = 5000
count_subimages_for_image = 10
window_size = [4, 4]
space_size = 2000
minicolumn = Minicolumn(space_size=space_size,
max_clusters=30000,
in_dimensions=64,
in_random_bits=25,
out_dimensions=20,
out_random_bits=15,
seed=42,
code_alignment=5,
in_point_activate=5,
out_point_activate=4,
in_cluster_modify=6,
out_cluster_modify=3,
lr=0.3,
binarization=0.1)
transforms = ContextTransformer(directs=4)
for i in range(space_size, 10000):
np.sort(np.random.permutation(64)[:25])
np.sort(np.random.permutation(20)[:15])
means = []
delta = []
ind = 0
def setUp(self):
window_size = [4, 4]
width_angle = np.pi / 2
strength = 0
non_zeros_bits = 5
space_size = 500
directs = 4
self.minicolumn = Minicolumn(space_size=space_size,
max_clusters=900,
in_dimensions=64,
in_random_bits=25,
out_dimensions=20,
out_random_bits=15,
seed=42,
code_alignment=5,
in_point_activate=5,
out_point_activate=4,
in_cluster_modify=6,
out_cluster_modify=3,
lr=0.3,
binarization=0.1)
self.transformer = ContextTransformer(directs=directs,
window_size=window_size,
width_angle=width_angle,
strength=strength,
non_zeros_bits=non_zeros_bits)
self.answer = [{
self.Answer.STATUS:
MINICOLUMN.LEARN,
self.Answer.OPT_OUT:
np.array(
[0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0]),
self.Answer.MEANS:
0.628,
self.Answer.CONT_NUM:
314,
self.Answer.OPT_IND:
7,
self.Answer.EMPTY_CODE:
False
}, {
self.Answer.STATUS:
MINICOLUMN.LEARN,
self.Answer.OPT_OUT:
np.array(
[0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]),
self.Answer.MEANS:
1.154,
self.Answer.CONT_NUM:
577,
self.Answer.OPT_IND:
20,
self.Answer.EMPTY_CODE:
False
}, {
self.Answer.STATUS:
MINICOLUMN.LEARN,
self.Answer.OPT_OUT:
np.array(
[0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]),
self.Answer.MEANS:
1.408,
self.Answer.CONT_NUM:
704,
self.Answer.OPT_IND:
14,
self.Answer.EMPTY_CODE:
False
}, {
self.Answer.STATUS:
MINICOLUMN.LEARN,
self.Answer.OPT_OUT:
np.array(
[1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1]),
self.Answer.MEANS:
1.928,
self.Answer.CONT_NUM:
964,
self.Answer.OPT_IND:
29,
self.Answer.EMPTY_CODE:
False
}, {
self.Answer.STATUS: MINICOLUMN.SLEEP,
self.Answer.OPT_OUT: None,
self.Answer.MEANS: 1.928,
self.Answer.CONT_NUM: 964,
self.Answer.OPT_IND: None,
self.Answer.EMPTY_CODE: False
}, {
self.Answer.STATUS: MINICOLUMN.SLEEP,
self.Answer.OPT_OUT: None,
self.Answer.MEANS: 1.928,
self.Answer.CONT_NUM: 964,
self.Answer.OPT_IND: None,
self.Answer.EMPTY_CODE: False
}]
class TestFunctionalMinicolumn(unittest.TestCase):
class Answer(Enum):
CONT_NUM = 0
OPT_IND = 1
OPT_OUT = 2
STATUS = 3
MEANS = 4
EMPTY_CODE = 5
@classmethod
def setUpClass(cls):
print('\n')
print('#########')
print('The executing of these tests can be a bit long')
print('#########')
def setUp(self):
window_size = [4, 4]
width_angle = np.pi / 2
strength = 0
non_zeros_bits = 5
space_size = 500
directs = 4
self.minicolumn = Minicolumn(space_size=space_size,
max_clusters=900,
in_dimensions=64,
in_random_bits=25,
out_dimensions=20,
out_random_bits=15,
seed=42,
code_alignment=5,
in_point_activate=5,
out_point_activate=4,
in_cluster_modify=6,
out_cluster_modify=3,
lr=0.3,
binarization=0.1)
self.transformer = ContextTransformer(directs=directs,
window_size=window_size,
width_angle=width_angle,
strength=strength,
non_zeros_bits=non_zeros_bits)
self.answer = [{
self.Answer.STATUS:
MINICOLUMN.LEARN,
self.Answer.OPT_OUT:
np.array(
[0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0]),
self.Answer.MEANS:
0.628,
self.Answer.CONT_NUM:
314,
self.Answer.OPT_IND:
7,
self.Answer.EMPTY_CODE:
False
}, {
self.Answer.STATUS:
MINICOLUMN.LEARN,
self.Answer.OPT_OUT:
np.array(
[0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]),
self.Answer.MEANS:
1.154,
self.Answer.CONT_NUM:
577,
self.Answer.OPT_IND:
20,
self.Answer.EMPTY_CODE:
False
}, {
self.Answer.STATUS:
MINICOLUMN.LEARN,
self.Answer.OPT_OUT:
np.array(
[0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]),
self.Answer.MEANS:
1.408,
self.Answer.CONT_NUM:
704,
self.Answer.OPT_IND:
14,
self.Answer.EMPTY_CODE:
False
}, {
self.Answer.STATUS:
MINICOLUMN.LEARN,
self.Answer.OPT_OUT:
np.array(
[1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1]),
self.Answer.MEANS:
1.928,
self.Answer.CONT_NUM:
964,
self.Answer.OPT_IND:
29,
self.Answer.EMPTY_CODE:
False
}, {
self.Answer.STATUS: MINICOLUMN.SLEEP,
self.Answer.OPT_OUT: None,
self.Answer.MEANS: 1.928,
self.Answer.CONT_NUM: 964,
self.Answer.OPT_IND: None,
self.Answer.EMPTY_CODE: False
}, {
self.Answer.STATUS: MINICOLUMN.SLEEP,
self.Answer.OPT_OUT: None,
self.Answer.MEANS: 1.928,
self.Answer.CONT_NUM: 964,
self.Answer.OPT_IND: None,
self.Answer.EMPTY_CODE: False
}]
def __add_to_dict(self, dict_var, key, value):
dict_tmp = dict_var[-1]
dict_tmp[key] = value
dict_var[-1] = dict_tmp
def __init_answ(self, answ):
answ.append({
self.Answer.EMPTY_CODE: None,
self.Answer.CONT_NUM: None,
self.Answer.OPT_IND: None,
self.Answer.OPT_OUT: None,
self.Answer.STATUS: None,
self.Answer.MEANS: None
})
def test_minicolumn(self):
df = pd.read_csv('../../data/test/test_image.csv',
header=None,
nrows=1)
answer = []
label, image = transformers.get_image(df, 0)
self.assertEqual(9, label)
for im_num in range(0, 6):
self.__init_answ(answer)
codes, context_numbes, image_sample = self.transformer.get_sample_codes(
image)
if codes is None:
self.__add_to_dict(answer, self.Answer.EMPTY_CODE, True)
continue
else:
self.__add_to_dict(answer, self.Answer.EMPTY_CODE, False)
opt_ind, out_code, status = self.minicolumn.learn(
codes, im_num, in_controversy=20, out_controversy=5)
self.__add_to_dict(answer, self.Answer.OPT_IND, opt_ind)
self.__add_to_dict(answer, self.Answer.OPT_OUT, out_code)
self.__add_to_dict(answer, self.Answer.CONT_NUM,
self.minicolumn.count_clusters)
self.__add_to_dict(answer, self.Answer.STATUS, status)
self.__add_to_dict(
answer, self.Answer.MEANS,
np.mean([len(p.clusters) for p in self.minicolumn.space]))
for item in zip(self.answer, answer):
for key in item[0]:
np.testing.assert_equal(item[0][key], item[1][key])
def test_size_space(self):
space_size = 100
minicolumn = Minicolumn(space_size=space_size, class_point=PointNoneMock)
self.assertEqual(len(minicolumn.space), space_size)
class TestPointUnsupervisedLearning(unittest.TestCase):
def setUp(self):
self.minicolumn = Minicolumn(
space_size=5,
in_random_bits=1,
out_random_bits=1,
in_dimensions=1,
out_dimensions=1,
code_alignment=1,
in_code_activate=0,
class_point=PointNoneMock
)
self.minicolumn_zeros = Minicolumn(
space_size=5,
in_random_bits=3,
out_random_bits=3,
in_dimensions=3,
out_dimensions=3,
code_alignment=2,
seed=42,
in_code_activate=0,
class_point=PointZerosMock
)
self.minicolumn_controversy_out = Minicolumn(
space_size=5,
in_random_bits=4,
out_random_bits=8,
in_dimensions=4,
out_dimensions=8,
code_alignment=4,
seed=42,
controversy=2,
class_point=PointEmptyMock
)
self.minicolumn_controversy_in = Minicolumn(
space_size=200,
in_random_bits=4,
out_random_bits=8,
in_dimensions=4,
out_dimensions=8,
code_alignment=2,
seed=42,
controversy=0.2,
in_code_activate=0,
class_point=PointControversyInMock
)
self.minicolumn_code_alignment = Minicolumn(
space_size=5,
in_random_bits=4,
out_random_bits=8,
in_dimensions=4,
out_dimensions=8,
code_alignment=4,
seed=42,
controversy=0.1,
in_code_activate=0,
min_active_points=0,
class_point=PointCodeAligmentMock
)
def test_continue_zeros_codes(self):
in_codes = [np.array([0])] * 3
min_in_code, min_out_code, min_ind_hamming = self.minicolumn.unsupervised_learning(in_codes=in_codes)
np.testing.assert_array_equal([[0]] * 3, in_codes)
self.assertIsNone(None, min_out_code)
self.assertIsNone(None, min_ind_hamming)
self.assertIsNone(None, min_in_code)
def test_out_not_detected(self):
in_codes = [np.array([1, 0, 1]), np.array([0, 1, 1]), np.array([1, 1, 0])]
min_in_code, min_out_code, min_ind_hamming = self.minicolumn_zeros.unsupervised_learning(in_codes=in_codes)
np.testing.assert_array_equal([[1, 0, 1], [0, 1, 1], [1, 1, 0]], in_codes)
np.testing.assert_array_equal([1, 1, 0], min_out_code)
np.testing.assert_array_equal([1, 0, 1], min_in_code)
self.assertEqual(0, min_ind_hamming)
def test_controversy_out(self):
in_codes = [np.array([1, 0, 1, 0]), np.array([0, 1, 1, 0]), np.array([1, 1, 0, 0])]
min_in_code, min_out_code, min_ind_hamming = self.minicolumn_controversy_out.unsupervised_learning(in_codes=in_codes)
np.testing.assert_array_equal([[1, 0, 1, 0], [0, 1, 1, 0], [1, 1, 0, 0]], in_codes)
self.assertIsNone(None, min_out_code)
self.assertIsNone(None, min_ind_hamming)
self.assertIsNone(None, min_in_code)
def test_code_alignment_more(self):
in_codes = [np.array([1, 1, 1, 1]), np.array([1, 1, 1, 1]), np.array([1, 1, 1, 1])]
min_in_code, min_out_code, min_ind_hamming = self.minicolumn_code_alignment.unsupervised_learning(in_codes)
np.testing.assert_array_equal([[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]], in_codes)
np.testing.assert_array_equal(np.array([1, 1, 0, 0, 0, 1, 0, 1]), min_out_code)
np.testing.assert_array_equal(np.array([1, 1, 1, 1]), min_in_code)
self.assertEqual(0, min_ind_hamming)
self.assertEqual(self.minicolumn_code_alignment.alignment, np.sum(min_out_code))
def test_code_alignment_less(self):
in_codes = [np.array([1, 0, 0, 0]), np.array([1, 0, 0, 0]), np.array([1, 0, 0, 0])]
min_in_code, min_out_code, min_ind_hamming = self.minicolumn_code_alignment.unsupervised_learning(in_codes)
np.testing.assert_array_equal([[1, 0, 0, 0], [1, 0, 0, 0], [1, 0, 0, 0]], in_codes)
np.testing.assert_array_equal(np.array([1, 1, 1, 0, 1, 0, 0, 0]), min_out_code)
np.testing.assert_array_equal([1, 0, 0, 0], min_in_code)
self.assertEqual(self.minicolumn_code_alignment.alignment, np.sum(min_out_code))
def test_code_alignment_eq(self):
in_codes = [np.array([1, 1, 0, 0]), np.array([1, 1, 0, 0]), np.array([1, 1, 0, 0])]
min_in_code, min_out_code, min_ind_hamming = self.minicolumn_code_alignment.unsupervised_learning(in_codes)
np.testing.assert_array_equal([[1, 1, 0, 0], [1, 1, 0, 0], [1, 1, 0, 0]], in_codes)
np.testing.assert_array_equal(np.array([1, 1, 0, 0, 1, 1, 0, 0]), min_out_code)
np.testing.assert_array_equal(np.array([1, 1, 0, 0]), min_in_code)
self.assertEqual(self.minicolumn_code_alignment.alignment, np.sum(min_out_code))
def test_code_controversy_in(self):
in_codes = [np.array([1, 1, 1, 1]), np.array([1, 1, 1, 1]), np.array([1, 1, 1, 1])]
min_in_code, min_out_code, min_ind_hamming = self.minicolumn_controversy_in.unsupervised_learning(
in_codes=in_codes, controversy_in=0
)
np.testing.assert_array_equal([[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]], in_codes)
self.assertIsNone(None, min_out_code)
self.assertIsNone(None, min_ind_hamming)
self.assertIsNone(None, min_in_code)
def test_code_hamming_dist_more(self):
in_codes = [np.array([1, 1, 1, 1]), np.array([0, 1, 1, 1]), np.array([1, 1, 1, 1])]
min_in_code, min_out_code, min_ind_hamming = self.minicolumn_controversy_in.unsupervised_learning(in_codes)
np.testing.assert_array_equal([[1, 1, 1, 1], [0, 1, 1, 1], [1, 1, 1, 1]], in_codes)
np.testing.assert_array_equal([1, 1, 1, 1], min_in_code)
np.testing.assert_array_equal([0, 1, 0, 0, 0, 1, 0, 0], min_out_code)
self.assertEqual(0, min_ind_hamming)
def test_code_min_ind_hamming(self):
in_codes = [np.array([0]), np.array([1]), np.array([1])]
min_in_code, min_out_code, min_ind_hamming = self.minicolumn.unsupervised_learning(in_codes)
np.testing.assert_array_equal([[0], [1], [1]], in_codes)
np.testing.assert_array_equal([1], min_in_code)
np.testing.assert_array_equal([1], min_out_code)
self.assertEqual(1, min_ind_hamming)
class TestPointSleep(unittest.TestCase):
def setUp(self):
self.minicolumn = Minicolumn(
space_size=5,
in_random_bits=1,
out_random_bits=1,
in_dimensions=1,
out_dimensions=1,
code_alignment=1,
class_point=PointNoneMock
)
self.minicolumn_activate = Minicolumn(
space_size=5,
in_random_bits=1,
out_random_bits=1,
in_point_activate=2,
out_point_activate=2,
in_dimensions=1,
out_dimensions=1,
code_alignment=1,
in_code_activate=2,
out_code_activate=2,
class_point=PointNoneMock
)
def test_assert_input_params(self):
self.assertRaises(ValueError, self.minicolumn.sleep, activate=2)
self.assertRaises(ValueError, self.minicolumn.sleep, activate=-1)
self.assertRaises(ValueError, self.minicolumn.sleep, activate=None)
def test_no_clusters(self):
clusters, the_same_clusters = self.minicolumn.sleep()
self.assertEqual(0, sum([len(cluster) for cluster in clusters]))
self.assertEqual(0, the_same_clusters)
def __constructor_active_mask_less_threshold(self, in_vec, out_vec):
self.minicolumn_activate.count_clusters = 5 * 5
for point in self.minicolumn_activate.space:
for _ in range(5):
point.clusters.append(ClusterMockWeight(in_vec, out_vec))
def test_active_out_mask_less(self):
self.__constructor_active_mask_less_threshold(np.array([0, 0, 0, 0, 0]), np.array([1, 1, 1, 1, 1]))
clusters, the_same_clusters = self.minicolumn_activate.sleep()
self.assertEqual(0, sum([len(cluster) for cluster in clusters]))
self.assertEqual(0, the_same_clusters)
def test_active_in_mask_less(self):
self.__constructor_active_mask_less_threshold(np.array([1, 1, 1, 1, 1]), np.array([0, 0, 0, 0, 0]))
clusters, the_same_clusters = self.minicolumn_activate.sleep()
self.assertEqual(0, sum([len(cluster) for cluster in clusters]))
self.assertEqual(0, the_same_clusters)
def test_sleep_0(self):
self.__constructor_active_mask_less_threshold(
np.array([1, 1, 1, 0, 0]),
np.array([1, 1, 1, 0, 0])
)
points, the_same_clusters = self.minicolumn_activate.sleep()
for clusters_number in points:
np.testing.assert_array_equal([0, 1, 2, 3, 4], clusters_number)
self.assertEqual(5, sum([len(point.clusters) for point in self.minicolumn_activate.space]))
self.assertEqual(20, the_same_clusters)
for point in self.minicolumn_activate.space:
self.assertEqual(1, len(point.clusters))
np.testing.assert_array_equal([1, 1, 1, 0, 0], point.clusters[0].in_w)
np.testing.assert_array_equal([1, 1, 1, 0, 0], point.clusters[0].out_w)
def test_sleep_1(self):
self.minicolumn_activate.count_clusters = 5 * 5
for point in self.minicolumn_activate.space:
for i in range(5):
point.clusters.append(ClusterMockWeight(
np.array([1] * i + [0] * (5 - i)),
np.array([1] * i + [0] * (5 - i))
))
points, the_same_clusters = self.minicolumn_activate.sleep()
for clusters_number in points:
np.testing.assert_array_equal([2, 3, 4], clusters_number)
self.assertEqual(15, sum([len(point.clusters) for point in self.minicolumn_activate.space]))
self.assertEqual(0, the_same_clusters)
for point in self.minicolumn_activate.space:
self.assertEqual(3, len(point.clusters))
np.testing.assert_array_equal([1, 1, 0, 0, 0], point.clusters[0].in_w)
np.testing.assert_array_equal([1, 1, 1, 0, 0], point.clusters[1].in_w)
np.testing.assert_array_equal([1, 1, 0, 0, 0], point.clusters[0].out_w)
np.testing.assert_array_equal([1, 1, 1, 0, 0], point.clusters[1].out_w)
class TestPointPredict(unittest.TestCase):
def setUp(self):
self.minicolumn_none = Minicolumn(
space_size=100,
in_random_bits=1,
out_random_bits=1,
in_dimensions=1,
out_dimensions=1,
code_alignment=1,
class_point=PointNoneMock
)
self.minicolumn = Minicolumn(
space_size=20,
in_random_bits=10,
out_random_bits=10,
in_dimensions=10,
out_dimensions=10,
seed=41,
controversy=0.05,
code_alignment=1,
min_active_points=0,
class_point=PointOddEvenMock
)
self.minicolumn_front = Minicolumn(
space_size=20,
in_random_bits=10,
out_random_bits=2,
in_dimensions=10,
out_dimensions=2,
seed=41,
controversy=0.05,
code_alignment=1,
class_point=PointEmptyMock
)
self.minicolumn_back = Minicolumn(
space_size=20,
in_random_bits=2,
out_random_bits=10,
in_dimensions=2,
out_dimensions=10,
seed=41,
controversy=0.05,
code_alignment=1,
class_point=PointEmptyMock
)
self.minicolumn_assert_dim_2 = Minicolumn(
space_size=20,
in_random_bits=2,
out_random_bits=10,
in_dimensions=2,
out_dimensions=10,
seed=41,
controversy=0.05,
code_alignment=1,
class_point=PointEmptyMock
)
def test_not_valid_value(self):
self.assertRaises(ValueError, self.minicolumn_front.front_predict, np.array([-1] * 10))
self.assertRaises(ValueError, self.minicolumn_front.front_predict, np.array([2] * 10))
self.assertRaises(ValueError, self.minicolumn_front.front_predict, np.array([0.8] * 10))
self.assertRaises(ValueError, self.minicolumn_front.front_predict, None)
self.assertRaises(ValueError, self.minicolumn_back.back_predict, np.array([-1] * 10))
self.assertRaises(ValueError, self.minicolumn_back.back_predict, np.array([2] * 10))
self.assertRaises(ValueError, self.minicolumn_back.back_predict, np.array([0.8] * 10))
self.assertRaises(ValueError, self.minicolumn_back.back_predict, None)
def __not_active_point(self, code, out_code, controversy, status):
np.testing.assert_array_equal([1], code)
self.assertEqual(None, out_code)
self.assertEqual(None, controversy)
self.assertEqual(MINICOLUMN_LEARNING.INACTIVE_POINTS, status)
def test_not_active_point(self):
code = np.array([1])
controversy, out_code, status = self.minicolumn_none.front_predict(code)
self.__not_active_point(code, out_code, controversy, status)
controversy, in_code, status = self.minicolumn_none.back_predict(code)
self.__not_active_point(code, out_code, controversy, status)
def test_not_valid_dim(self):
self.assertRaises(AssertionError, self.minicolumn_assert_dim_2.front_predict, np.array([1] * 3))
self.assertRaises(AssertionError, self.minicolumn_assert_dim_2.back_predict, np.array([1] * 8))
def __front_active_point(self, input_code, status, output_code, controversy, target, target_controversy):
np.testing.assert_array_equal(np.array([1] * 10), input_code)
np.testing.assert_array_equal(target, output_code)
self.assertEqual(target_controversy, controversy)
self.assertEqual(MINICOLUMN_LEARNING.ACCEPT, status)
def test_active_point(self):
input_code = np.array([1] * 10)
controversy, output_code, status = self.minicolumn.back_predict(input_code)
self.__front_active_point(
input_code, status, output_code, controversy, np.array([1, 0, 1, 0, 1, 0, 0, 1, 1, 0]), 2
)
controversy, output_code, status = self.minicolumn.front_predict(input_code)
self.__front_active_point(
input_code, status, output_code, controversy, np.array([1, 0, 1, 0, 0, 0, 1, 0, 0, 0]), 4
)