def test_constructor_shape(self):
"""Test construction of shape of tensor"""
ranks = ["M", "K"]
shape = [4, 8]
t = Tensor(rank_ids=ranks, shape=shape)
self.assertEqual(t.getRankIds(), ranks)
self.assertEqual(t.getRoot().getRankIds(), ranks)
self.assertEqual(t.getShape(), shape)
self.assertEqual(t.getRoot().getShape(), shape)
def test_constructor_rank_0D(self):
"""Test construction of 0-D tensor"""
t = Tensor(rank_ids=[])
p = t.getRoot()
p += 1
self.assertEqual(p, 1)
def test_constructor_empty(self):
"""Test construction of empty tensor"""
ranks = ["M", "K"]
t = Tensor(rank_ids=ranks)
self.assertEqual(t.getRankIds(), ranks)
self.assertEqual(t.getRoot().getRankIds(), ranks)
def test_shape_0D(self):
"""Test shpe of 0-D tensor"""
t = Tensor(rank_ids=[])
p = t.getRoot()
p += 1
self.assertEqual(t.getRankIds(), [])
self.assertEqual(t.getShape(), [])
def test_fromYAMLfile_0D(self):
"""Test construction of 0-D tensor from a YAML file"""
tensor_ref = Tensor(rank_ids=[])
root = tensor_ref.getRoot()
root += 2
tensor = Tensor.fromYAMLfile("./data/tensor_0d.yaml")
self.assertTrue(tensor == tensor_ref)
def test_0D(self):
"Test sum to rank 0 tensor"
a = Tensor.fromYAMLfile("./data/conv-activations-a.yaml")
z = Tensor(rank_ids=[])
a_m = a.getRoot()
z_ref = z.getRoot()
for m_coord, (a_val) in a_m:
z_ref += a_val
self.assertEqual(z_ref, 12)
def test_copy(self):
"""Copy a tensor"""
a = Tensor.fromYAMLfile("./data/test_tensor-1.yaml")
z = Tensor(rank_ids=["M", "K"])
a_m = a.getRoot()
z_m = z.getRoot()
for m, (z_k, a_k) in z_m << a_m:
for k, (z_ref, a_val) in z_k << a_k:
z_ref += a_val
self.assertEqual(a, z)
def test_getPayloadRef_0d(self):
"""Test getPayloadRef of a 0-D tensor"""
p_ref = 10
t = Tensor(rank_ids=[])
r = t.getRoot()
r <<= p_ref
p = t.getPayloadRef()
self.assertEqual(p_ref, p)
p = t.getPayloadRef(0)
self.assertEqual(p_ref, p)
p = t.getPayloadRef(1)
self.assertEqual(p_ref, p)
def test_print_0D(self):
"""Test printing a 0-D tensor"""
a = Tensor(rank_ids=[])
p = a.getRoot()
p += 2
a_s_ref = "<2>"
a_s = f"{a}"
self.assertEqual(a_s, a_s_ref)
a_r_ref = "T()/[Payload(2)]"
a_r = f"{a!r}"
self.assertEqual(a_r, a_r_ref)
def test_fromUncompressed_20(self):
"""Test construction of a tensor a scalar"""
t_ref = Tensor(rank_ids=[])
p = t_ref.getRoot()
p += 2
t0 = Tensor.fromUncompressed([], 2)
self.assertEqual(t0, t_ref)
t1 = Tensor.fromUncompressed(rank_ids=[], root=2)
self.assertEqual(t1, t_ref)
t2 = Tensor.fromUncompressed(root=2)
self.assertEqual(t2, t_ref)
def test_dot(self):
"Test dot product"
a = Tensor.fromYAMLfile("./data/tensor_sum_a.yaml")
b = Tensor.fromYAMLfile("./data/tensor_sum_b.yaml")
z = Tensor(rank_ids=["M"])
a_m = a.getRoot()
b_m = b.getRoot()
z_m = z.getRoot()
for m_coord, (z_ref, (a_k, b_k)) in z_m << (a_m & b_m):
for k_coord, (a_val, b_val) in a_k & b_k:
z_ref += a_val * b_val
z_correct = Tensor.fromYAMLfile("./data/tensor_dot_z.yaml")
self.assertEqual(z, z_correct)
def test_default_nonscalar(self):
"""Test set/get of nonzero default"""
t = Tensor(rank_ids=["X", "Y", "Z"])
v = (10, 10)
e = Fiber([], [])
t.setDefault(v)
self.assertEqual(t.getDefault(), v)
t_root = t.getRoot()
x = t_root.getPayload(1)
self.assertEqual(x, e)
y = t_root.getPayload(1, 2)
self.assertEqual(y, e)
z = t_root.getPayload(1, 2, 3)
self.assertEqual(z, v)
def test_default(self):
"""Test of default default"""
t = Tensor(rank_ids=["X", "Y", "Z"])
e = Fiber([], [])
self.assertEqual(t.getDefault(), 0)
t_root = t.getRoot()
x = t_root.getPayload(1)
self.assertEqual(x, e)
self.assertEqual(x.getDefault(), Fiber)
y = t_root.getPayload(1, 2)
self.assertEqual(y, e)
self.assertEqual(y.getDefault(), 0)
z = t_root.getPayload(1, 2, 3)
self.assertEqual(z, 0)
def test_conv1d_ws(self):
"""Convolution 1d ws"""
w = Tensor.fromYAMLfile("./data/conv-weights-a.yaml")
i = Tensor.fromYAMLfile("./data/conv-activations-a.yaml")
o = Tensor(rank_ids=["Q"])
w_r = w.getRoot()
i_h = i.getRoot()
o_q = o.getRoot()
W = w_r.maxCoord() + 1
I = i_h.maxCoord() + 1
Q = I - W + 1
for r, (w_val) in w_r:
for q, (o_q_ref,
i_val) in o_q << i_h.project(lambda h: h - r, (0, Q)):
o_q_ref += w_val * i_val
o_ref = Tensor.fromYAMLfile("./data/conv-output-a.yaml")
self.assertEqual(o, o_ref)
def test_conv1d_os(self):
"""Convolution 1d os"""
w = Tensor.fromYAMLfile("./data/conv-weights-a.yaml")
i = Tensor.fromYAMLfile("./data/conv-activations-a.yaml")
o = Tensor(rank_ids=["Q"])
w_r = w.getRoot()
i_h = i.getRoot()
o_q = o.getRoot()
W = w_r.maxCoord() + 1
I = i_h.maxCoord() + 1
Q = I - W + 1
output_shape = Fiber(coords=range(Q), initial=1)
for q, (o_q_ref, _) in o_q << output_shape:
for r, (w_val, i_val) in w_r.project(lambda r: q + r) & i_h:
o_q_ref += w_val * i_val
o_ref = Tensor.fromYAMLfile("./data/conv-output-os-a.yaml")
self.assertEqual(o, o_ref)
# Adjacency matrix
a = Tensor.fromUncompressed(
["S", "D"], [[0, 1, 1, 0, 0, 0], [0, 0, 1, 1, 0, 0], [0, 0, 0, 1, 1, 0],
[0, 0, 0, 0, 1, 1], [1, 0, 0, 0, 0, 1], [1, 1, 0, 0, 0, 0]])
# Fringe (current and next)
f0 = Tensor.fromUncompressed(["D"], [1, 0, 0, 0, 0, 0])
# Distance
d = Tensor(rank_ids=["S"])
# Get root fibers
a_s = a.getRoot()
f0_d = f0.getRoot()
d_d = d.getRoot()
print("BFS")
level = 1
while (f0_d.countValues() > 0):
f0_d.print("\nFringe")
f1 = Tensor(rank_ids=["D"])
f1_d = f1.getRoot()
for s, (_, a_d) in f0_d & a_s:
print(f"Processing source {s}")
print(f"Neighbors:\n {a_d}")
print("")
data_dir = "../../data"
a = Tensor.fromYAMLfile(os.path.join(data_dir, "spMspV-a.yaml"))
b = Tensor.fromYAMLfile(os.path.join(data_dir, "spMspV-b.yaml"))
z = Tensor(rank_ids=["M"])
a.print("A Tensor")
b.print("B Tensor")
z.print("Z Tensor")
a_m = a.getRoot()
b_k = b.getRoot()
z_m = z.getRoot()
a_m.print("A Tensor - Rank M")
b_k.print("B Tensor - Rank K")
z_m.print("Z Tensor - Rank M")
for m_coord, (z_ref, a_k) in (z_m << a_m):
for k_coord, (a_val, b_val) in (a_k & b_k):
z_ref += a_val * b_val # reducing a scalar
z.print("\nZ Tensor")
print("")
print("--------------------------------------")
print("")
print("----------------------------------------")
print("")
data_dir = "../../data"
w = Tensor.fromYAMLfile(os.path.join(data_dir, "conv-weights-a.yaml"))
i = Tensor.fromYAMLfile(os.path.join(data_dir, "conv-activations-a.yaml"))
o = Tensor(rank_ids=["Q"])
w.print("W Tensor")
i.print("I Tensor")
o.print("O Tensor")
w_r = w.getRoot()
i_h = i.getRoot()
o_q = o.getRoot()
W = w_r.maxCoord() + 1
I = i_h.maxCoord() + 1
Q = I - W + 1
w_r.print("W Tensor - R rank - size=%s" % W)
i_h.print("I Tensor - H rank - size=%s" % I)
o_q.print("O Tensor - Q rank - size=%s" % I)
print("Convolution")
for h, (i_val) in i_h:
print(f"Processing input: ({h}, ({i_val}))")
for q, (o_q_ref, w_val) in o_q << w_r.project(lambda r: h - r, (0, Q)):
print(f" Processing output ({q}, ({o_q_ref}, {w_val})")
