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