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))