def test_reduce(self):
arr = np.arange(1, 5).reshape([2, 2])
t = pt.from_array(arr)
res = pt.tensor()
i, j = pt.get_index_vars(2)
res[None] = pt.sum(j, pt.sum(i, t[i, j]))
self.assertEqual(res[0], np.sum(arr))
def test_mod(self):
arr = np.arange(1, 5).reshape([2, 2])
t = pt.from_array(arr)
t1 = pt.tensor([2, 2], pt.dense)
i, j = pt.get_index_vars(2)
t1[i, j] = pt.remainder(t[i, j], 2)
self.assertEqual(t1, arr % 2)
def test_tensor_from_numpy(self):
tensor = pt.from_array(self.c_array, copy=True)
tensor_arr = np.array(tensor)
tensor_copy = np.array(tensor, copy=False)
self.assertFalse(tensor_copy.flags["WRITEABLE"])
self.assertTrue(np.array_equal(tensor_arr, self.c_array))
self.assertTrue(np.array_equal(tensor_copy, self.c_array))
def _getitem(self, index):
if index is None or isinstance(index, int) or len(index) == 0:
return __pt_impl_get_item(self, index)
# Fallback to numpy slicing if an input has slice().
for i in index:
if isinstance(i, slice):
return pt.from_array(self.to_array()[index])
return __pt_impl_get_item(self, index)
def test_array_copy_C_and_F_style(self):
# Getting a reference to taco then back to numpy should return the same data with the read only flag set to true
# only for C and F style arrays. Arrays of different forms will always be copied
c_copy = pt.from_array(self.c_array, copy=False)
f_copy = pt.from_array(self.f_array, copy=False)
same_c_array = np.array(c_copy, copy=False)
same_f_array = np.array(f_copy, copy=False)
pointer_self_f, read_only_flag_self_f = self.f_array.__array_interface__['data']
pointer_self_c, read_only_flag_self_c = self.c_array.__array_interface__['data']
pointer_c, read_only_flag_c = same_c_array.__array_interface__['data']
pointer_f, read_only_flag_f = same_f_array.__array_interface__['data']
self.assertFalse(read_only_flag_self_c)
self.assertFalse(read_only_flag_self_f)
self.assertTrue(read_only_flag_c)
self.assertTrue(read_only_flag_f)
self.assertEqual(pointer_c, pointer_self_c)
self.assertEqual(pointer_f, pointer_self_f)
def setUp(self):
self.dir_name = tempfile.mkdtemp()
self.names = [os.path.join(self.dir_name, dtype.__repr__() + "{}".format(i)) for i, dtype in enumerate(types)]
tensors = [np.ones([3, 3]).astype(pt.as_np_dtype(dt)) for dt in types]
self.tensors = [pt.from_array(t, copy=True) for t in tensors]
self.comp_tensors = [pt.tensor([3, 3], pt.csc, dt) for dt in types]
self.coord = [2, 2]
self.val = 10
for t2 in self.comp_tensors:
t2.insert(self.coord, self.val) # force .tns to infer 3x3 shape
def random(shape, format='dense', density=1.):
if format == "dense":
return pt.from_array(np.random.random(shape))
elif format == "coo":
sp_tensor = sparse.random(shape, density=density, format='coo')
pt_tensor = pt.tensor(shape, pt.compressed)
for i in range(len(sp_tensor.data)):
pt_tensor.insert(sp_tensor.coords[:, i], sp_tensor.data[i])
return pt_tensor
else:
raise NotImplementedError
def test_to_and_from_np_and_sp(self):
arrs = [np.array([[1, 0], [0, 4]]).astype(pt.as_np_dtype(dt)) for dt in types]
csrs = [csr_matrix(arr) for arr in arrs]
cscs = [csc_matrix(arr) for arr in arrs]
tens = [pt.from_array(arr) for arr in arrs]
for ten, csr in zip(tens, csrs):
self.assertEqual((ten.to_sp_csr() != csr).nnz, 0)
for ten, csc in zip(tens, cscs):
self.assertEqual((ten.to_sp_csc() != csc).nnz, 0)
for ten, arr in zip(tens, arrs):
self.assertTrue(np.array_equal(ten.to_array(), arr))
def tensor(data, dtype=None, format="dense"):
"""
Parameters
----------
data: the input multidimentional array.
dtype: datatype
format: a string denoting the tensor datatype.
if "dense", then return a dense tensor.
if "coo", then return a sparse tensor in the COO format.
"""
if format == "dense":
return pt.from_array(np.array(data))
elif format == "coo":
sp_tensor = sparse.COO.from_numpy(np.array(data, dtype=dtype))
pt_tensor = pt.tensor(sp_tensor.shape, pt.compressed)
for i in range(len(sp_tensor.data)):
pt_tensor.insert(sp_tensor.coords[:, i], sp_tensor.data[i])
return pt_tensor
else:
raise NotImplementedError
def test_reshaped_array(self):
i, j, k = 2, 4, 3
a = np.arange(i*j*k).reshape([i, j, k])
a = a.transpose([1, 0, 2])
# It is possible to handle transposes in general without copying but this isn't supported yet
taco_should_copy = pt.from_array(a, copy=False)
# taco should have ignored the copy flag
new_arr = np.array(taco_should_copy, copy=False)
pointer_a, read_only_flag_a = a.__array_interface__['data']
pointer_new, read_only_flag_new = new_arr.__array_interface__['data']
self.assertFalse(read_only_flag_a)
self.assertTrue(read_only_flag_new)
self.assertNotEqual(pointer_a, pointer_new) # taco should force copy
self.assertEqual(taco_should_copy.shape, [j, i, k])
# Check that data is the same
for ii in range(i):
for jj in range(j):
for kk in range(k):
self.assertEqual(a[jj, ii, kk], taco_should_copy[jj, ii, kk])
def test_neg(self):
arr = np.arange(1, 5).reshape([2, 2])
t = pt.from_array(arr)
self.assertEqual(-t, -arr)
def inv(a):
return pt.from_array(np.linalg.inv(a.to_array()))
def tensorinv(a, ind=2):
return pt.from_array(np.linalg.tensorinv(a.to_array(), ind))
def svd(matrix):
u, s, vh = np.linalg.svd(matrix.to_array())
return pt.from_array(u), pt.from_array(s), pt.from_array(vh)
def identity(n):
return pt.from_array(np.identity(n))
def ones(shape, dtype=None):
return pt.from_array(np.ones(shape, dtype))
