def test_cross_function_d(self):
"""Test case d: outer-producting a vector and a sequence of vectors:
Options:
- first vector is a Categorical, second sequence of vectors is a numpy ndarray
(dtype = object)
- first vector is a Categorical, second sequence of vectors is a Categorical
(where self.IS_AOA = True))
"""
array_path = os.path.join(os.getcwd(), "tests/data/cross_d.mat")
mat_contents = loadmat(file_name=array_path)
result_1 = mat_contents["result1"]
random_vec = Categorical(values=mat_contents["random_vec"])
states = mat_contents["s"]
for i in range(len(states)):
states[i] = states[i].squeeze()
# first way, where first array is a Categorical, second array is a numpy ndarray
# (dtype = object)
result_1a_py = random_vec.cross(states)
self.assertTrue(np.isclose(result_1, result_1a_py).all())
# second way, where first array is a Categorical, second array is a Categorical
# (where self.IS_AOA = True)
states = Categorical(values=states[0])
result_1b_py = random_vec.cross(states)
self.assertTrue(np.isclose(result_1, result_1b_py).all())
def test_cross_function_b(self):
"""Test case b: outer-producting two vectors together:
Options:
- both vectors are stored in single Categorical (with two entries, where self.AoA == True)
- first vector is a Categorical (self.AoA = False) and second array is a numpy ndarray
(non-object array)
- first vector is a Categorical, second vector is also Categorical
"""
array_path = os.path.join(os.getcwd(), "tests/data/cross_b.mat")
mat_contents = loadmat(file_name=array_path)
result_1 = mat_contents["result1"]
result_2 = mat_contents["result2"]
# first way, where both arrays as stored as two entries in a single AoA Categorical
states = Categorical(values=mat_contents["s"][0])
result_1_py = states.cross()
self.assertTrue(np.isclose(result_1, result_1_py).all())
# second way (type 1), where first array is a Categorical, second array is a
# straight numpy array
states_firstFactor = Categorical(values=mat_contents["s"][0][0])
states_secondFactor = mat_contents["s"][0][1]
result_2a_py = states_firstFactor.cross(states_secondFactor)
self.assertTrue(np.isclose(result_2, result_2a_py).all())
# second way (type 2), where first array is a Categorical, second array
# is another Categorical
states_firstFactor = Categorical(values=mat_contents["s"][0][0])
states_secondFactor = Categorical(values=mat_contents["s"][0][1])
result_2b_py = states_firstFactor.cross(states_secondFactor)
self.assertTrue(np.isclose(result_2, result_2b_py).all())
def test_normalize_multi_factor(self):
values_1 = np.random.rand(5)
values_2 = np.random.rand(4, 3)
values = np.array([values_1, values_2])
c = Categorical(values=values)
c.normalize()
self.assertTrue(c.is_normalized())
def test_dot_function_a(self):
""" test with vectors and matrices, discrete state / outcomes """
array_path = os.path.join(os.getcwd(), "tests/data/dot_a.mat")
mat_contents = loadmat(file_name=array_path)
A = mat_contents["A"]
obs = mat_contents["o"]
states = mat_contents["s"]
states = np.array(states, dtype=object)
result_1 = mat_contents["result1"]
result_2 = mat_contents["result2"]
result_3 = mat_contents["result3"]
A = Categorical(values=A)
result_1_py = A.dot(obs, return_numpy=True)
self.assertTrue(np.isclose(result_1, result_1_py).all())
result_2_py = A.dot(states, return_numpy=True)
result_2_py = result_2_py.astype("float64")[:, np.newaxis]
self.assertTrue(np.isclose(result_2, result_2_py).all())
result_3_py = A.dot(states, dims_to_omit=[0], return_numpy=True)
self.assertTrue(np.isclose(result_3, result_3_py).all())
def test_copy(self):
values = np.random.rand(3, 2)
c = Categorical(values=values)
c_copy = c.copy()
self.assertTrue(np.array_equal(c_copy.values, c.values))
c_copy.values = c_copy.values * 2
self.assertFalse(np.array_equal(c_copy.values, c.values))
def test_dot_function_e(self):
""" CONTINUOUS states and outcomes, but add a final (fourth) hidden state factor """
array_path = os.path.join(os.getcwd(), "tests/data/dot_e.mat")
mat_contents = loadmat(file_name=array_path)
A = mat_contents["A"]
obs = mat_contents["o"]
states = mat_contents["s"]
states_array_version = np.empty(states.shape[1], dtype=object)
for i in range(states.shape[1]):
states_array_version[i] = states[0][i][0]
result_1 = mat_contents["result1"]
result_2 = mat_contents["result2"]
result_3 = mat_contents["result3"]
A = Categorical(values=A)
result_1_py = A.dot(obs, return_numpy=True)
self.assertTrue(np.isclose(result_1, result_1_py).all())
result_2_py = A.dot(states_array_version, return_numpy=True)
result_2_py = result_2_py.astype("float64")[:, np.newaxis]
self.assertTrue(np.isclose(result_2, result_2_py).all())
result_3_py = A.dot(states_array_version,
dims_to_omit=[0],
return_numpy=True)
self.assertTrue(np.isclose(result_3, result_3_py).all())
def test_multi_factor_init_values_expand(self):
values_1 = np.random.rand(5)
values_2 = np.random.rand(4)
values = np.array([values_1, values_2])
c = Categorical(values=values)
self.assertEqual(c.shape, (2, ))
self.assertEqual(c[0].shape, (5, 1))
self.assertEqual(c[1].shape, (4, 1))
def test_dot_function_c_Cat(self):
""" test with vectors and matrices, discrete state / outcomes but with a
third hidden state factor. Now, when arguments themselves are
instances of Categorical
"""
array_path = os.path.join(os.getcwd(), "tests/data/dot_c.mat")
mat_contents = loadmat(file_name=array_path)
A = mat_contents["A"]
obs = Categorical(values=mat_contents["o"])
states = mat_contents["s"]
states_array_version = np.empty(states.shape[1], dtype=object)
for i in range(states.shape[1]):
states_array_version[i] = states[0][i][0]
states_array_version = Categorical(values=states_array_version)
result_1 = mat_contents["result1"]
result_2 = mat_contents["result2"]
result_3 = mat_contents["result3"]
A = Categorical(values=A)
result_1_py = A.dot(obs, return_numpy=True)
self.assertTrue(np.isclose(result_1, result_1_py).all())
result_2_py = A.dot(states_array_version, return_numpy=True)
result_2_py = result_2_py.astype("float64")[:, np.newaxis]
self.assertTrue(np.isclose(result_2, result_2_py).all())
result_3_py = A.dot(states_array_version,
dims_to_omit=[0],
return_numpy=True)
self.assertTrue(np.isclose(result_3, result_3_py).all())
def test_cross_function_c(self):
"""Test case c: outer-producting a vector and a matrix together:
Options:
- first vector is a Categorical, and the matrix argument is a numpy ndarray
(non-object array)
- first vector is a Categorical, and the matrix argument is also a Categorical
"""
array_path = os.path.join(os.getcwd(), "tests/data/cross_c.mat")
mat_contents = loadmat(file_name=array_path)
result_1 = mat_contents["result1"]
random_vec = Categorical(values=mat_contents["random_vec"])
# first way, where first array is a Categorical, second array is a numpy ndarray
random_matrix = mat_contents["random_matrix"]
result_1a_py = random_vec.cross(random_matrix)
self.assertTrue(np.isclose(result_1, result_1a_py).all())
# second way, where first array is a Categorical, second array is a Categorical
random_matrix = Categorical(values=mat_contents["random_matrix"])
result_1b_py = random_vec.cross(random_matrix)
self.assertTrue(np.isclose(result_1, result_1b_py).all())
def test_is_normalized(self):
values = np.array([[0.7, 0.5], [0.3, 0.5]])
c = Categorical(values=values)
self.assertTrue(c.is_normalized())
values = np.array([[0.2, 0.8], [0.3, 0.5]])
c = Categorical(values=values)
self.assertFalse(c.is_normalized())
def test_contains_zeros(self):
values = np.array([[1.0, 0.0], [1.0, 1.0]])
c = Categorical(values=values)
self.assertTrue(c.contains_zeros())
values = np.array([[1.0, 1.0], [1.0, 1.0]])
c = Categorical(values=values)
self.assertFalse(c.contains_zeros())
def test_cross_function_a(self):
"""Test case a: passing in a single-factor hidden state vector -
under both options of Categorical: where self.AOA is True or False """
array_path = os.path.join(os.getcwd(), "tests/data/cross_a.mat")
mat_contents = loadmat(file_name=array_path)
result_1 = mat_contents["result1"]
result_2 = mat_contents["result2"]
states = np.empty(1, dtype=object)
states[0] = mat_contents["s"][0, 0].squeeze()
states = Categorical(
values=states
) # this would create a 1-dimensional array of arrays (namely, self.IS_AOA == True)
result_1_py = states.cross()
self.assertTrue(np.isclose(result_1, result_1_py).all())
states = Categorical(
values=mat_contents["s"][0, 0].squeeze()
) # this creates a simple single-factor Categorical (namely, self.IS_AOA == False)
result_2_py = states.cross()
self.assertTrue(np.isclose(result_2, result_2_py).all())
def test_remove_zeros(self):
values = np.array([[1.0, 0.0], [1.0, 1.0]])
c = Categorical(values=values)
self.assertTrue((c.values == 0.0).any())
c.remove_zeros()
self.assertFalse((c.values == 0.0).any())
from inferactively import Categorical # nopep8
# %% Debugging for Categorical.dot()
array_path = os.path.join(os.getcwd(), "tests/data/dot_a.mat")
mat_contents = loadmat(file_name=array_path)
A = mat_contents["A"]
obs = mat_contents["o"]
states = mat_contents["s"]
states = np.array(states, dtype=object)
result_1 = mat_contents["result1"]
result_2 = mat_contents["result2"]
result_3 = mat_contents["result3"]
A = Categorical(values=A)
result_1_py = A.dot(obs, return_numpy=True)
print(np.isclose(result_1, result_1_py).all())
result_2_py = A.dot(states, return_numpy=True)
result_2_py = result_2_py.astype("float64")[:, np.newaxis]
print(np.isclose(result_2, result_2_py).all())
result_3_py = A.dot(states, dims_to_omit=[0], return_numpy=True)
print(np.isclose(result_3, result_3_py).all())
# now try by putting obs and states into Categoricals themselves
obs = Categorical(values=mat_contents["o"])
states = Categorical(values=mat_contents["s"][0])
def test_normalize_two_dim(self):
values = np.array([[1.0, 1.0], [1.0, 1.0]])
c = Categorical(values=values)
expected_values = np.array([[0.5, 0.5], [0.5, 0.5]])
c.normalize()
self.assertTrue(np.array_equal(c.values, expected_values))
def test_log(self):
values = np.random.rand(3, 2)
log_values = np.log(values)
c = Categorical(values=values)
self.assertTrue(np.array_equal(c.log(return_numpy=True), log_values))
def test_shape(self):
values = np.random.rand(3, 2)
c = Categorical(values=values)
self.assertEqual(c.shape, (3, 2))
def test_ndim(self):
values = np.random.rand(3, 2)
c = Categorical(values=values)
self.assertEqual(c.ndim, c.values.ndim)
def test_init_empty(self):
c = Categorical()
self.assertEqual(c.ndim, 2)
def test_cross_function_e(self):
"""Test case e: outer-producting two sequences of vectors:
Options:
- First sequence is an AoA Categorical, second sequence is a numpy ndarray
(dtype = object)
- First sequence is NOT an AoA Categorical, second sequence is a numpy ndarray
(dtype = object)
- First sequence is an AoA Categorical, second sequence is an AoA Categorical
- First sequence is NOT an AoA Categorical, second sequence is an AoA Categorical
"""
array_path = os.path.join(os.getcwd(), "tests/data/cross_e.mat")
mat_contents = loadmat(file_name=array_path)
result_1 = mat_contents["result1"]
s2 = mat_contents["s2"]
s2_new = np.empty(s2.shape[1], dtype=object)
for i in range(len(s2_new)):
s2_new[i] = s2[0][i].squeeze()
# first way (type 1), first sequence is a Categorical (self.AOA = True) and
# second sequence is a numpy ndarray (dtype = object)
s1 = Categorical(values=mat_contents["s1"][0])
result_1aa_py = s1.cross(s2_new)
self.assertTrue(np.isclose(result_1, result_1aa_py).all())
# first way (type 2), first sequence is a Categorical (self.AOA = False) and
# second sequence is a numpy ndarray (dtype = object)
s1 = Categorical(values=mat_contents["s1"][0][0])
result_1ab_py = s1.cross(s2_new)
self.assertTrue(np.isclose(result_1, result_1ab_py).all())
s2_new = Categorical(values=mat_contents["s2"][0])
# second way (type 1), first sequence is a Categorical (self.AOA = True)
# and second sequence is a Categorical
s1 = Categorical(values=mat_contents["s1"][0])
result_2aa_py = s1.cross(s2_new)
self.assertTrue(np.isclose(result_1, result_2aa_py).all())
# second way (type 2), first sequence is a Categorical (self.AOA = False)
# and second sequence is a Categorical
s1 = Categorical(values=mat_contents["s1"][0][0])
result_2ab_py = s1.cross(s2_new)
self.assertTrue(np.isclose(result_1, result_2ab_py).all())
def test_multi_factor_init_dims(self):
c = Categorical(dims=[[5, 4], [4, 3]])
self.assertEqual(c.shape, (2, ))
self.assertEqual(c[0].shape, (5, 4))
self.assertEqual(c[1].shape, (4, 3))
def test_init_overload(self):
with self.assertRaises(ValueError):
values = np.random.rand(3, 2)
_ = Categorical(dims=2, values=values)
def test_float_conversion(self):
values = np.array([2, 3])
self.assertEqual(values.dtype, np.int)
c = Categorical(values=values)
self.assertEqual(c.values.dtype, np.float64)
def test_init_dims_int_expand(self):
c = Categorical(dims=5)
self.assertEqual(c.shape, (5, 1))
def test_entropy(self):
values = np.random.rand(3, 2)
entropy = -np.sum(values * np.log(values), 0)
c = Categorical(values=values)
self.assertTrue(np.array_equal(c.entropy(return_numpy=True), entropy))