def test_norm(self): a = ht.arange(9, dtype=ht.float32, split=0) - 4 self.assertTrue( ht.allclose(ht.linalg.norm(a), ht.float32(np.linalg.norm(a.numpy())).item(), atol=1e-5)) a.resplit_(axis=None) self.assertTrue( ht.allclose(ht.linalg.norm(a), ht.float32(np.linalg.norm(a.numpy())).item(), atol=1e-5)) b = ht.array([[-4.0, -3.0, -2.0], [-1.0, 0.0, 1.0], [2.0, 3.0, 4.0]], split=0) self.assertTrue( ht.allclose(ht.linalg.norm(b), ht.float32(np.linalg.norm(b.numpy())).item(), atol=1e-5)) b.resplit_(axis=1) self.assertTrue( ht.allclose(ht.linalg.norm(b), ht.float32(np.linalg.norm(b.numpy())).item(), atol=1e-5)) with self.assertRaises(TypeError): c = np.arange(9) - 4 ht.linalg.norm(c)
def test_full_like(self): # scalar like_int = ht.full_like(3, 4) self.assertIsInstance(like_int, ht.tensor) self.assertEqual(like_int.shape, (1, )) self.assertEqual(like_int.lshape, (1, )) self.assertEqual(like_int.split, None) self.assertEqual(like_int.dtype, ht.float32) self.assertTrue(ht.allclose(like_int, ht.float32(4))) # sequence like_str = ht.full_like('abc', 2) self.assertIsInstance(like_str, ht.tensor) self.assertEqual(like_str.shape, (3, )) self.assertEqual(like_str.lshape, (3, )) self.assertEqual(like_str.split, None) self.assertEqual(like_str.dtype, ht.float32) self.assertTrue(ht.allclose(like_str, ht.float32(2))) # elaborate tensor zeros = ht.zeros(( 2, 3, ), dtype=ht.uint8) like_zeros = ht.full_like(zeros, 7) self.assertIsInstance(like_zeros, ht.tensor) self.assertEqual(like_zeros.shape, ( 2, 3, )) self.assertEqual(like_zeros.lshape, ( 2, 3, )) self.assertEqual(like_zeros.split, None) self.assertEqual(like_zeros.dtype, ht.float32) self.assertTrue(ht.allclose(like_zeros, ht.float32(7))) # elaborate tensor with split zeros_split = ht.zeros(( 2, 3, ), dtype=ht.uint8, split=0) like_zeros_split = ht.full_like(zeros_split, 6) self.assertIsInstance(like_zeros_split, ht.tensor) self.assertEqual(like_zeros_split.shape, ( 2, 3, )) self.assertLessEqual(like_zeros_split.lshape[0], 2) self.assertEqual(like_zeros_split.lshape[1], 3) self.assertEqual(like_zeros_split.split, 0) self.assertEqual(like_zeros_split.dtype, ht.float32) self.assertTrue(ht.allclose(like_zeros_split, ht.float32(6))) # exceptions with self.assertRaises(TypeError): ht.ones_like(zeros, dtype='abc') with self.assertRaises(TypeError): ht.ones_like(zeros, split='axis')
def test_isclose(self): size = ht.communication.MPI_WORLD.size a = ht.float32([[2, 2], [2, 2]], device=ht_device) b = ht.float32([[2.00005, 2.00005], [2.00005, 2.00005]], device=ht_device) c = ht.zeros((4 * size, 6), split=0, device=ht_device) d = ht.zeros((4 * size, 6), split=1, device=ht_device) e = ht.zeros((4 * size, 6), device=ht_device) self.assertIsInstance(ht.isclose(a, b), ht.DNDarray) self.assertTrue(ht.isclose(a, b).shape == (2, 2)) self.assertFalse(ht.isclose(a, b)[0][0].item()) self.assertTrue(ht.isclose(a, b, atol=1e-04)[0][1].item()) self.assertTrue(ht.isclose(a, b, rtol=1e-04)[1][0].item()) self.assertTrue(ht.isclose(a, 2)[0][1].item()) self.assertTrue(ht.isclose(a, 2.0)[0][0].item()) self.assertTrue(ht.isclose(2, a)[1][1].item()) self.assertTrue(ht.isclose(c, d).shape == (4 * size, 6)) self.assertTrue(ht.isclose(c, e)[0][0].item()) self.assertTrue(e.isclose(c)[-1][-1].item()) # test scalar input self.assertIsInstance(ht.isclose(2.0, 2.00005), bool) with self.assertRaises(TypeError): ht.isclose(a, (2, 2, 2, 2)) with self.assertRaises(TypeError): ht.isclose(a, "?") with self.assertRaises(TypeError): ht.isclose("?", a)
def test_allclose(self): a = ht.float32([[2, 2], [2, 2]]) b = ht.float32([[2.00005, 2.00005], [2.00005, 2.00005]]) self.assertFalse(ht.allclose(a, b)) self.assertTrue(ht.allclose(a, b, atol=1e-04)) self.assertTrue(ht.allclose(a, b, rtol=1e-04)) with self.assertRaises(TypeError): ht.allclose(a, (2, 2, 2, 2))
def setUpClass(cls): cls.a_scalar = 2.0 cls.an_int_scalar = 2 cls.a_vector = ht.float32([2, 2], device=ht_device) cls.another_vector = ht.float32([2, 2, 2], device=ht_device) cls.a_tensor = ht.array([[1.0, 2.0], [3.0, 4.0]], device=ht_device) cls.another_tensor = ht.array([[2.0, 2.0], [2.0, 2.0]], device=ht_device) cls.a_split_tensor = cls.another_tensor.copy().resplit_(0) cls.errorneous_type = (2, 2)
def setUpClass(cls): super(TestArithmetics, cls).setUpClass() cls.a_scalar = 2.0 cls.an_int_scalar = 2 cls.a_vector = ht.float32([2, 2]) cls.another_vector = ht.float32([2, 2, 2]) cls.a_tensor = ht.array([[1.0, 2.0], [3.0, 4.0]]) cls.another_tensor = ht.array([[2.0, 2.0], [2.0, 2.0]]) cls.a_split_tensor = cls.another_tensor.copy().resplit_(0) cls.erroneous_type = (2, 2)
def setUpClass(cls): super(TestRelational, cls).setUpClass() cls.a_scalar = 2.0 cls.an_int_scalar = 2 cls.a_vector = ht.float32([2, 2]) cls.another_vector = ht.float32([2, 2, 2]) cls.a_tensor = ht.array([[1.0, 2.0], [3.0, 4.0]]) cls.another_tensor = ht.array([[2.0, 2.0], [2.0, 2.0]]) cls.a_split_tensor = cls.another_tensor.copy().resplit_(0) cls.split_ones_tensor = ht.ones((2, 2), split=1) cls.errorneous_type = (2, 2)
def test_full_like(self): # scalar like_int = ht.full_like(3, 4) self.assertIsInstance(like_int, ht.DNDarray) self.assertEqual(like_int.shape, (1, )) self.assertEqual(like_int.lshape, (1, )) self.assertEqual(like_int.split, None) self.assertEqual(like_int.dtype, ht.float32) self.assertTrue(ht.allclose(like_int, ht.float32(4, device=ht_device))) # sequence like_str = ht.full_like("abc", 2) self.assertIsInstance(like_str, ht.DNDarray) self.assertEqual(like_str.shape, (3, )) self.assertEqual(like_str.lshape, (3, )) self.assertEqual(like_str.split, None) self.assertEqual(like_str.dtype, ht.float32) self.assertTrue(ht.allclose(like_str, ht.float32(2, device=ht_device))) # elaborate tensor zeros = ht.zeros((2, 3), dtype=ht.uint8, device=ht_device) like_zeros = ht.full_like(zeros, 7) self.assertIsInstance(like_zeros, ht.DNDarray) self.assertEqual(like_zeros.shape, (2, 3)) self.assertEqual(like_zeros.lshape, (2, 3)) self.assertEqual(like_zeros.split, None) self.assertEqual(like_zeros.dtype, ht.float32) self.assertTrue( ht.allclose(like_zeros, ht.float32(7, device=ht_device))) # elaborate tensor with split zeros_split = ht.zeros((2, 3), dtype=ht.uint8, split=0, device=ht_device) like_zeros_split = ht.full_like(zeros_split, 6) self.assertIsInstance(like_zeros_split, ht.DNDarray) self.assertEqual(like_zeros_split.shape, (2, 3)) self.assertLessEqual(like_zeros_split.lshape[0], 2) self.assertEqual(like_zeros_split.lshape[1], 3) self.assertEqual(like_zeros_split.split, 0) self.assertEqual(like_zeros_split.dtype, ht.float32) self.assertTrue( ht.allclose(like_zeros_split, ht.float32(6, device=ht_device))) # exceptions with self.assertRaises(TypeError): ht.ones_like(zeros, dtype="abc", device=ht_device) with self.assertRaises(TypeError): ht.ones_like(zeros, split="axis", device=ht_device)
def test_div(self): result = ht.array([[0.5, 1.0], [1.5, 2.0]], device=ht_device) commutated_result = ht.array([[2.0, 1.0], [2.0 / 3.0, 0.5]], device=ht_device) self.assertTrue( ht.equal(ht.div(self.a_scalar, self.a_scalar), ht.float32([1.0]))) self.assertTrue(ht.equal(ht.div(self.a_tensor, self.a_scalar), result)) self.assertTrue( ht.equal(ht.div(self.a_scalar, self.a_tensor), commutated_result)) self.assertTrue( ht.equal(ht.div(self.a_tensor, self.another_tensor), result)) self.assertTrue(ht.equal(ht.div(self.a_tensor, self.a_vector), result)) self.assertTrue( ht.equal(ht.div(self.a_tensor, self.an_int_scalar), result)) self.assertTrue( ht.equal(ht.div(self.a_split_tensor, self.a_tensor), commutated_result)) with self.assertRaises(ValueError): ht.div(self.a_tensor, self.another_vector) with self.assertRaises(TypeError): ht.div(self.a_tensor, self.errorneous_type) with self.assertRaises(TypeError): ht.div("T", "s")
def test_fmod(self): result = ht.array([[1.0, 0.0], [1.0, 0.0]]) an_int_tensor = ht.array([[5, 3], [4, 1]]) integer_result = ht.array([[1, 1], [0, 1]]) commutated_result = ht.array([[0.0, 0.0], [2.0, 2.0]]) zero_tensor = ht.zeros((2, 2)) a_float = ht.array([5.3]) another_float = ht.array([1.9]) result_float = ht.array([1.5]) self.assertTrue(ht.equal(ht.fmod(self.a_scalar, self.a_scalar), ht.float32([0.0]))) self.assertTrue(ht.equal(ht.fmod(self.a_tensor, self.a_tensor), zero_tensor)) self.assertTrue(ht.equal(ht.fmod(self.a_tensor, self.an_int_scalar), result)) self.assertTrue(ht.equal(ht.fmod(self.a_tensor, self.another_tensor), result)) self.assertTrue(ht.equal(ht.fmod(self.a_tensor, self.a_vector), result)) self.assertTrue(ht.equal(ht.fmod(self.a_tensor, self.an_int_scalar), result)) self.assertTrue(ht.equal(ht.fmod(an_int_tensor, self.an_int_scalar), integer_result)) self.assertTrue(ht.equal(ht.fmod(self.a_scalar, self.a_tensor), commutated_result)) self.assertTrue(ht.equal(ht.fmod(self.a_split_tensor, self.a_tensor), commutated_result)) self.assertTrue(ht.allclose(ht.fmod(a_float, another_float), result_float)) with self.assertRaises(ValueError): ht.fmod(self.a_tensor, self.another_vector) with self.assertRaises(TypeError): ht.fmod(self.a_tensor, self.errorneous_type) with self.assertRaises(TypeError): ht.fmod("T", "s")
def test_right_hand_side_operations(self): """ This test ensures that for each arithmetic operation (e.g. +, -, *, ...) that is implemented in the tensor class, it works both ways. Examples -------- >>> import heat as ht >>> T = ht.float32([[1., 2.], [3., 4.]]) >>> assert T * 3 == 3 * T """ operators = ( ("__add__", operator.add, True), ("__sub__", operator.sub, False), ("__mul__", operator.mul, True), ("__truediv__", operator.truediv, False), ("__floordiv__", operator.floordiv, False), ("__mod__", operator.mod, False), ("__pow__", operator.pow, False), ) tensor = ht.float32([[1, 4], [2, 3]]) num = 3 for (attr, op, commutative) in operators: try: func = tensor.__getattribute__(attr) except AttributeError: continue self.assertTrue(callable(func)) res_1 = op(tensor, num) res_2 = op(num, tensor) if commutative: self.assertTrue(ht.equal(res_1, res_2))
def test_argmin(self): data = ht.float32([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]) comparison = torch.Tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]) # check basics self.assertTrue( (ht.argmin(data, axis=0)._tensor__array == comparison.argmin(0)).all()) self.assertIsInstance(ht.argmin(data, axis=1), ht.tensor) self.assertIsInstance(data.argmin(), ht.tensor) # check combinations of split and axis torch.manual_seed(1) random_data = ht.random.randn(3, 3, 3) torch.manual_seed(1) random_data_split = ht.random.randn(3, 3, 3, split=0) self.assertTrue( (ht.argmin(random_data, axis=0)._tensor__array == random_data_split.argmin( axis=0)._tensor__array).all()) self.assertTrue( (ht.argmin(random_data, axis=1)._tensor__array == random_data_split.argmin( axis=1)._tensor__array).all()) self.assertIsInstance(ht.argmin(random_data_split, axis=1), ht.tensor) self.assertIsInstance(random_data_split.argmin(), ht.tensor) # check argmin over all float elements of 3d tensor locally self.assertEqual(random_data.argmin().shape, (1, )) self.assertEqual(random_data.argmin().lshape, (1, )) self.assertEqual(random_data.argmin().dtype, ht.int64) self.assertEqual(random_data.argmin().split, None) # check argmin over all float elements of splitted 3d tensor self.assertIsInstance(random_data_split.argmin(axis=1), ht.tensor) self.assertEqual(random_data_split.argmin(axis=1).shape, (3, 1, 3)) self.assertEqual(random_data_split.argmin().split, None) # check argmin over all float elements of splitted 5d tensor with negative axis random_data_split_neg = ht.random.randn(1, 2, 3, 4, 5, split=1) self.assertIsInstance(random_data_split_neg.argmin(axis=-2), ht.tensor) self.assertEqual( random_data_split_neg.argmin(axis=-2).shape, (1, 2, 3, 1, 5)) self.assertEqual(random_data_split_neg.argmin(axis=-2).dtype, ht.int64) self.assertEqual(random_data_split_neg.argmin().split, None) # check exceptions with self.assertRaises(NotImplementedError): data.argmin(axis=(0, 1)) with self.assertRaises(TypeError): data.argmin(axis=1.1) with self.assertRaises(TypeError): data.argmin(axis='y') with self.assertRaises(ValueError): ht.argmin(data, axis=-4)
def test_exp(self): elements = 10 tmp = torch.arange(elements, dtype=torch.float64, device=self.device.torch_device).exp() comparison = ht.array(tmp) # exponential of float32 float32_tensor = ht.arange(elements, dtype=ht.float32) float32_exp = ht.exp(float32_tensor) self.assertIsInstance(float32_exp, ht.DNDarray) self.assertEqual(float32_exp.dtype, ht.float32) self.assertTrue(ht.allclose(float32_exp, comparison.astype(ht.float32))) # exponential of float64 float64_tensor = ht.arange(elements, dtype=ht.float64) float64_exp = ht.exp(float64_tensor) self.assertIsInstance(float64_exp, ht.DNDarray) self.assertEqual(float64_exp.dtype, ht.float64) self.assertTrue(ht.allclose(float64_exp, comparison)) # exponential of ints, automatic conversion to intermediate floats int32_tensor = ht.arange(elements, dtype=ht.int32) int32_exp = ht.exp(int32_tensor) self.assertIsInstance(int32_exp, ht.DNDarray) self.assertEqual(int32_exp.dtype, ht.float32) self.assertTrue(ht.allclose(int32_exp, ht.float32(comparison))) # exponential of longs, automatic conversion to intermediate floats int64_tensor = ht.arange(elements, dtype=ht.int64) int64_exp = int64_tensor.exp() self.assertIsInstance(int64_exp, ht.DNDarray) self.assertEqual(int64_exp.dtype, ht.float64) self.assertTrue(ht.allclose(int64_exp, comparison)) # check exceptions with self.assertRaises(TypeError): ht.exp([1, 2, 3]) with self.assertRaises(TypeError): ht.exp("hello world") # Tests with split expected = torch.arange(10, dtype=torch.float32, device=self.device.torch_device).exp() actual = ht.arange(10, split=0, dtype=ht.float32).exp() self.assertEqual(actual.gshape, tuple(expected.shape)) self.assertEqual(actual.split, 0) actual = actual.resplit_(None) self.assertEqual(actual.lshape, expected.shape) self.assertTrue(torch.equal(expected, actual.larray)) self.assertEqual(actual.dtype, ht.float32)
def test_full(self): # simple tensor data = ht.full((10, 2), 4, device=ht_device) self.assertIsInstance(data, ht.DNDarray) self.assertEqual(data.shape, (10, 2)) self.assertEqual(data.lshape, (10, 2)) self.assertEqual(data.dtype, ht.float32) self.assertEqual(data._DNDarray__array.dtype, torch.float32) self.assertEqual(data.split, None) self.assertTrue(ht.allclose(data, ht.float32(4.0, device=ht_device))) # non-standard dtype tensor data = ht.full((10, 2), 4, dtype=ht.int32, device=ht_device) self.assertIsInstance(data, ht.DNDarray) self.assertEqual(data.shape, (10, 2)) self.assertEqual(data.lshape, (10, 2)) self.assertEqual(data.dtype, ht.int32) self.assertEqual(data._DNDarray__array.dtype, torch.int32) self.assertEqual(data.split, None) self.assertTrue(ht.allclose(data, ht.int32(4, device=ht_device))) # split tensor data = ht.full((10, 2), 4, split=0, device=ht_device) self.assertIsInstance(data, ht.DNDarray) self.assertEqual(data.shape, (10, 2)) self.assertLessEqual(data.lshape[0], 10) self.assertEqual(data.lshape[1], 2) self.assertEqual(data.dtype, ht.float32) self.assertEqual(data._DNDarray__array.dtype, torch.float32) self.assertEqual(data.split, 0) self.assertTrue(ht.allclose(data, ht.float32(4.0, device=ht_device))) # exceptions with self.assertRaises(TypeError): ht.full("(2, 3,)", 4, dtype=ht.float64, device=ht_device) with self.assertRaises(ValueError): ht.full((-1, 3), 2, dtype=ht.float64, device=ht_device) with self.assertRaises(TypeError): ht.full((2, 3), dtype=ht.float64, split="axis", device=ht_device)
def test_allclose(self): a = ht.float32([[2, 2], [2, 2]]) b = ht.float32([[2.00005, 2.00005], [2.00005, 2.00005]]) c = ht.zeros((4, 6), split=0) d = ht.zeros((4, 6), split=1) e = ht.zeros((4, 6)) self.assertFalse(ht.allclose(a, b)) self.assertTrue(ht.allclose(a, b, atol=1e-04)) self.assertTrue(ht.allclose(a, b, rtol=1e-04)) self.assertTrue(ht.allclose(a, 2)) self.assertTrue(ht.allclose(a, 2.0)) self.assertTrue(ht.allclose(2, a)) self.assertTrue(ht.allclose(c, d)) self.assertTrue(ht.allclose(c, e)) self.assertTrue(e.allclose(c)) with self.assertRaises(TypeError): ht.allclose(a, (2, 2, 2, 2)) with self.assertRaises(TypeError): ht.allclose(a, "?") with self.assertRaises(TypeError): ht.allclose("?", a)
def test_add(self): result = ht.array([[3.0, 4.0], [5.0, 6.0]]) self.assertTrue(ht.equal(ht.add(self.a_scalar, self.a_scalar), ht.float32([4.0]))) self.assertTrue(ht.equal(ht.add(self.a_tensor, self.a_scalar), result)) self.assertTrue(ht.equal(ht.add(self.a_scalar, self.a_tensor), result)) self.assertTrue(ht.equal(ht.add(self.a_tensor, self.another_tensor), result)) self.assertTrue(ht.equal(ht.add(self.a_tensor, self.a_vector), result)) self.assertTrue(ht.equal(ht.add(self.a_tensor, self.an_int_scalar), result)) self.assertTrue(ht.equal(ht.add(self.a_split_tensor, self.a_tensor), result)) with self.assertRaises(ValueError): ht.add(self.a_tensor, self.another_vector) with self.assertRaises(TypeError): ht.add(self.a_tensor, self.errorneous_type) with self.assertRaises(TypeError): ht.add("T", "s")
def test_astype(self): data = ht.float32([[1, 2, 3], [4, 5, 6]], device=ht_device) # check starting invariant self.assertEqual(data.dtype, ht.float32) # check the copy case for uint8 as_uint8 = data.astype(ht.uint8) self.assertIsInstance(as_uint8, ht.DNDarray) self.assertEqual(as_uint8.dtype, ht.uint8) self.assertEqual(as_uint8._DNDarray__array.dtype, torch.uint8) self.assertIsNot(as_uint8, data) # check the copy case for uint8 as_float64 = data.astype(ht.float64, copy=False) self.assertIsInstance(as_float64, ht.DNDarray) self.assertEqual(as_float64.dtype, ht.float64) self.assertEqual(as_float64._DNDarray__array.dtype, torch.float64) self.assertIs(as_float64, data)
def test_square(self): elements = 25 tmp = torch.square( torch.arange(elements, dtype=torch.float64, device=self.device.torch_device)) comparison = ht.array(tmp) # squares of float32 float32_tensor = ht.arange(elements, dtype=ht.float32) float32_square = ht.square(float32_tensor) self.assertIsInstance(float32_square, ht.DNDarray) self.assertEqual(float32_square.dtype, ht.float32) self.assertTrue( ht.allclose(float32_square, comparison.astype(ht.float32), 1e-09)) # squares of float64 float64_tensor = ht.arange(elements, dtype=ht.float64) float64_square = ht.square(float64_tensor) self.assertIsInstance(float64_square, ht.DNDarray) self.assertEqual(float64_square.dtype, ht.float64) self.assertTrue(ht.allclose(float64_square, comparison, 1e-09)) # squares of ints, automatic conversion to intermediate floats int32_tensor = ht.arange(elements, dtype=ht.int32) int32_square = ht.square(int32_tensor) self.assertIsInstance(int32_square, ht.DNDarray) self.assertEqual(int32_square.dtype, ht.float32) self.assertTrue( ht.allclose(int32_square, ht.float32(comparison), 1e-09)) # squares of longs, automatic conversion to intermediate floats int64_tensor = ht.arange(elements, dtype=ht.int64) int64_square = int64_tensor.square() self.assertIsInstance(int64_square, ht.DNDarray) self.assertEqual(int64_square.dtype, ht.float64) self.assertTrue(ht.allclose(int64_square, comparison, 1e-09)) # check exceptions with self.assertRaises(TypeError): ht.square([1, 2, 3]) with self.assertRaises(TypeError): ht.square("hello world")
def test_log1p(self): elements = 15 tmp = torch.arange(1, elements, dtype=torch.float64, device=self.device.torch_device).log1p() comparison = ht.array(tmp) # logarithm of float32 float32_tensor = ht.arange(1, elements, dtype=ht.float32) float32_log1p = ht.log1p(float32_tensor) self.assertIsInstance(float32_log1p, ht.DNDarray) self.assertEqual(float32_log1p.dtype, ht.float32) self.assertTrue( ht.allclose(float32_log1p, comparison.astype(ht.float32))) # logarithm of float64 float64_tensor = ht.arange(1, elements, dtype=ht.float64) float64_log1p = ht.log1p(float64_tensor) self.assertIsInstance(float64_log1p, ht.DNDarray) self.assertEqual(float64_log1p.dtype, ht.float64) self.assertTrue(ht.allclose(float64_log1p, comparison)) # logarithm of ints, automatic conversion to intermediate floats int32_tensor = ht.arange(1, elements, dtype=ht.int32) int32_log1p = ht.log1p(int32_tensor) self.assertIsInstance(int32_log1p, ht.DNDarray) self.assertEqual(int32_log1p.dtype, ht.float32) self.assertTrue(ht.allclose(int32_log1p, ht.float32(comparison))) # logarithm of longs, automatic conversion to intermediate floats int64_tensor = ht.arange(1, elements, dtype=ht.int64) int64_log1p = int64_tensor.log1p() self.assertIsInstance(int64_log1p, ht.DNDarray) self.assertEqual(int64_log1p.dtype, ht.float64) self.assertTrue(ht.allclose(int64_log1p, comparison)) # check exceptions with self.assertRaises(TypeError): ht.log1p([1, 2, 3]) with self.assertRaises(TypeError): ht.log1p("hello world")
def test_expm1(self): elements = 10 tmp = torch.arange(elements, dtype=torch.float64, device=self.device.torch_device).expm1() comparison = ht.array(tmp) # expm1onential of float32 float32_tensor = ht.arange(elements, dtype=ht.float32) float32_expm1 = ht.expm1(float32_tensor) self.assertIsInstance(float32_expm1, ht.DNDarray) self.assertEqual(float32_expm1.dtype, ht.float32) self.assertTrue( ht.allclose(float32_expm1, comparison.astype(ht.float32))) # expm1onential of float64 float64_tensor = ht.arange(elements, dtype=ht.float64) float64_expm1 = ht.expm1(float64_tensor) self.assertIsInstance(float64_expm1, ht.DNDarray) self.assertEqual(float64_expm1.dtype, ht.float64) self.assertTrue(ht.allclose(float64_expm1, comparison)) # expm1onential of ints, automatic conversion to intermediate floats int32_tensor = ht.arange(elements, dtype=ht.int32) int32_expm1 = ht.expm1(int32_tensor) self.assertIsInstance(int32_expm1, ht.DNDarray) self.assertEqual(int32_expm1.dtype, ht.float32) self.assertTrue(ht.allclose(int32_expm1, ht.float32(comparison))) # expm1onential of longs, automatic conversion to intermediate floats int64_tensor = ht.arange(elements, dtype=ht.int64) int64_expm1 = int64_tensor.expm1() self.assertIsInstance(int64_expm1, ht.DNDarray) self.assertEqual(int64_expm1.dtype, ht.float64) self.assertTrue(ht.allclose(int64_expm1, comparison)) # check exceptions with self.assertRaises(TypeError): ht.expm1([1, 2, 3]) with self.assertRaises(TypeError): ht.expm1("hello world")
def test_any(self): # float values, minor axis x = ht.float32([[2.7, 0, 0], [0, 0, 0], [0, 0.3, 0]], device=ht_device) any_tensor = x.any(axis=1) res = ht.uint8([1, 0, 1], device=ht_device) self.assertIsInstance(any_tensor, ht.DNDarray) self.assertEqual(any_tensor.shape, (3, )) self.assertEqual(any_tensor.dtype, ht.bool) self.assertTrue(ht.equal(any_tensor, res)) # integer values, major axis, output tensor any_tensor = ht.zeros((2, ), device=ht_device) x = ht.int32([[0, 0], [0, 0], [0, 1]], device=ht_device) ht.any(x, axis=0, out=any_tensor) res = ht.uint8([0, 1], device=ht_device) self.assertIsInstance(any_tensor, ht.DNDarray) self.assertEqual(any_tensor.shape, (2, )) self.assertEqual(any_tensor.dtype, ht.bool) self.assertTrue(ht.equal(any_tensor, res)) # float values, no axis x = ht.float64([[0, 0, 0], [0, 0, 0]], device=ht_device) res = ht.zeros(1, dtype=ht.uint8, device=ht_device) any_tensor = ht.any(x) self.assertIsInstance(any_tensor, ht.DNDarray) self.assertEqual(any_tensor.shape, (1, )) self.assertEqual(any_tensor.dtype, ht.bool) self.assertTrue(ht.equal(any_tensor, res)) # split tensor, along axis x = ht.arange(10, split=0, device=ht_device) any_tensor = ht.any(x, axis=0) res = ht.uint8([1], device=ht_device) self.assertIsInstance(any_tensor, ht.DNDarray) self.assertEqual(any_tensor.shape, (1, )) self.assertEqual(any_tensor.dtype, ht.bool) self.assertTrue(ht.equal(any_tensor, res))
def test_full(self): # simple tensor data = ht.full(( 10, 2, ), 4) self.assertIsInstance(data, ht.tensor) self.assertEqual(data.shape, ( 10, 2, )) self.assertEqual(data.lshape, ( 10, 2, )) self.assertEqual(data.dtype, ht.float32) self.assertEqual(data._tensor__array.dtype, torch.float32) self.assertEqual(data.split, None) self.assertTrue(ht.allclose(data, ht.float32(4.0))) # non-standard dtype tensor data = ht.full(( 10, 2, ), 4, dtype=ht.int32) self.assertIsInstance(data, ht.tensor) self.assertEqual(data.shape, ( 10, 2, )) self.assertEqual(data.lshape, ( 10, 2, )) self.assertEqual(data.dtype, ht.int32) self.assertEqual(data._tensor__array.dtype, torch.int32) self.assertEqual(data.split, None) self.assertTrue(ht.allclose(data, ht.int32(4))) # split tensor data = ht.full(( 10, 2, ), 4, split=0) self.assertIsInstance(data, ht.tensor) self.assertEqual(data.shape, ( 10, 2, )) self.assertLessEqual(data.lshape[0], 10) self.assertEqual(data.lshape[1], 2) self.assertEqual(data.dtype, ht.float32) self.assertEqual(data._tensor__array.dtype, torch.float32) self.assertEqual(data.split, 0) self.assertTrue(ht.allclose(data, ht.float32(4.0))) # exceptions with self.assertRaises(TypeError): ht.full('(2, 3,)', 4, dtype=ht.float64) with self.assertRaises(ValueError): ht.full(( -1, 3, ), 2, dtype=ht.float64) with self.assertRaises(TypeError): ht.full(( 2, 3, ), dtype=ht.float64, split='axis')
import unittest import torch import heat as ht FLOAT_EPSILON = 1e-4 T = ht.float32([[1, 2], [3, 4]]) s = 2.0 s_int = 2 T1 = ht.float32([[2, 2], [2, 2]]) v = ht.float32([2, 2]) v2 = ht.float32([2, 2, 2]) T_s = ht.tensor(T1._tensor__array, T1.shape, T1.dtype, 0, None, None) Ts = ht.ones((2, 2), split=1) otherType = (2, 2) class TestOperations(unittest.TestCase): def test_equal(self): self.assertTrue(ht.equal(T, T)) self.assertFalse(ht.equal(T, T1)) self.assertFalse(ht.equal(T, s)) self.assertFalse(ht.equal(T1, s)) def test_eq(self): T_r = ht.uint8([[0, 1], [0, 0]]) self.assertTrue(ht.equal(ht.eq(s, s), ht.uint8([1]))) self.assertTrue(ht.equal(ht.eq(T, s), T_r)) self.assertTrue(ht.equal(ht.eq(s, T), T_r))
def test_add(self): # test basics result = ht.array([[3.0, 4.0], [5.0, 6.0]]) self.assertTrue( ht.equal(ht.add(self.a_scalar, self.a_scalar), ht.float32(4.0))) self.assertTrue(ht.equal(ht.add(self.a_tensor, self.a_scalar), result)) self.assertTrue(ht.equal(ht.add(self.a_scalar, self.a_tensor), result)) self.assertTrue( ht.equal(ht.add(self.a_tensor, self.another_tensor), result)) self.assertTrue(ht.equal(ht.add(self.a_tensor, self.a_vector), result)) self.assertTrue( ht.equal(ht.add(self.a_tensor, self.an_int_scalar), result)) self.assertTrue( ht.equal(ht.add(self.a_split_tensor, self.a_tensor), result)) # Single element split a = ht.array([1], split=0) b = ht.array([1, 2], split=0) c = ht.add(a, b) self.assertTrue(ht.equal(c, ht.array([2, 3]))) if c.comm.size > 1: if c.comm.rank < 2: self.assertEqual(c.larray.size()[0], 1) else: self.assertEqual(c.larray.size()[0], 0) # test with differently distributed DNDarrays a = ht.ones(10, split=0) b = ht.zeros(10, split=0) c = a[:-1] + b[1:] self.assertTrue((c == 1).all()) self.assertTrue(c.lshape == a[:-1].lshape) c = a[1:-1] + b[1:-1] # test unbalanced self.assertTrue((c == 1).all()) self.assertTrue(c.lshape == a[1:-1].lshape) # test one unsplit a = ht.ones(10, split=None) b = ht.zeros(10, split=0) c = a[:-1] + b[1:] self.assertTrue((c == 1).all()) self.assertEqual(c.lshape, b[1:].lshape) c = b[:-1] + a[1:] self.assertTrue((c == 1).all()) self.assertEqual(c.lshape, b[:-1].lshape) # broadcast in split dimension a = ht.ones((1, 10), split=0) b = ht.zeros((2, 10), split=0) c = a + b self.assertTrue((c == 1).all()) self.assertTrue(c.lshape == b.lshape) c = b + a self.assertTrue((c == 1).all()) self.assertTrue(c.lshape == b.lshape) with self.assertRaises(ValueError): ht.add(self.a_tensor, self.another_vector) with self.assertRaises(TypeError): ht.add(self.a_tensor, self.erroneous_type) with self.assertRaises(TypeError): ht.add("T", "s")