def allequal(tensor1, tensor2, **kwargs):
"""Returns True if two tensors are element-wise equal along a given axis.
This function is equivalent to calling ``np.all(tensor1 == tensor2, **kwargs)``,
but allows for ``tensor1`` and ``tensor2`` to differ in type.
Args:
tensor1 (tensor_like): tensor to compare
tensor2 (tensor_like): tensor to compare
**kwargs: Accepts any keyword argument that is accepted by ``np.all``,
such as ``axis``, ``out``, and ``keepdims``. See the `NumPy documentation
<https://numpy.org/doc/stable/reference/generated/numpy.all.html>`__ for
more details.
Returns:
ndarray, bool: If ``axis=None``, a logical AND reduction is applied to all elements
and a boolean will be returned, indicating if all elements evaluate to ``True``. Otherwise,
a boolean NumPy array will be returned.
**Example**
>>> a = torch.tensor([1, 2])
>>> b = np.array([1, 2])
>>> allequal(a, b)
True
"""
t1 = ar.to_numpy(tensor1)
t2 = ar.to_numpy(tensor2)
return np.all(t1 == t2, **kwargs)
def test_translator_random_normal(backend):
from autoray import numpy as anp
x = anp.random.normal(100.0, 0.1, size=(4, 5), like=backend)
if backend == 'sparse':
assert (x.data > 90.0).all()
assert (x.data < 110.0).all()
return
assert (ar.to_numpy(x) > 90.0).all()
assert (ar.to_numpy(x) < 110.0).all()
if backend == 'tensorflow':
x32 = ar.do('random.normal',
100.0,
0.1,
dtype='float32',
size=(4, 5),
like=backend)
assert x32.dtype == 'float32'
assert (ar.to_numpy(x32) > 90.0).all()
assert (ar.to_numpy(x32) < 110.0).all()
# test default single scalar
x = anp.random.normal(loc=1500, scale=10, like=backend)
assert 1000 <= ar.to_numpy(x) < 2000
def test_translator_random_uniform(backend):
from autoray import numpy as anp
if backend == 'sparse':
pytest.xfail("Sparse will have zeros")
x = anp.random.uniform(low=-10, size=(4, 5), like=backend)
assert (ar.to_numpy(x) > -10).all()
assert (ar.to_numpy(x) < 1.0).all()
# test default single scalar
x = anp.random.uniform(low=1000, high=2000, like=backend)
assert 1000 <= ar.to_numpy(x) < 2000
def test_mgs(backend):
if backend == 'sparse':
pytest.xfail("Sparse doesn't support linear algebra yet...")
x = gen_rand((3, 5), backend)
Ux = modified_gram_schmidt(x)
y = ar.do('sum', Ux @ ar.dag(Ux))
assert ar.to_numpy(y) == pytest.approx(3)
def test_linalg_svd_square(backend):
if backend == 'sparse':
pytest.xfail("Sparse doesn't support linear algebra yet...")
x = gen_rand((5, 4), backend)
U, s, V = ar.do('linalg.svd', x)
assert (ar.infer_backend(x) == ar.infer_backend(U) == ar.infer_backend(s)
== ar.infer_backend(V) == backend)
y = U @ ar.do('diag', s, like=x) @ V
diff = ar.do('sum', abs(y - x))
assert ar.to_numpy(diff) < 1e-8
def allclose(a, b, rtol=1e-05, atol=1e-08, **kwargs):
"""Wrapper around np.allclose, allowing tensors ``a`` and ``b``
to differ in type"""
try:
# Some frameworks may provide their own allclose implementation.
# Try and use it if available.
res = np.allclose(a, b, rtol=rtol, atol=atol, **kwargs)
except (TypeError, AttributeError):
# Otherwise, convert the input to NumPy arrays.
#
# TODO: replace this with a bespoke, framework agnostic
# low-level implementation to avoid the NumPy conversion:
#
# np.abs(a - b) <= atol + rtol * np.abs(b)
#
t1 = ar.to_numpy(a)
t2 = ar.to_numpy(b)
res = np.allclose(t1, t2, rtol=rtol, atol=atol, **kwargs)
return res
def test_dtype_specials(backend, creation, dtype):
import numpy as np
x = ar.do(creation, shape=(2, 3), like=backend)
if backend == 'torch' and 'complex' in dtype:
pytest.xfail("Pytorch doesn't support complex numbers yet...")
x = ar.astype(x, dtype)
assert ar.get_dtype_name(x) == dtype
x = ar.to_numpy(x)
assert isinstance(x, np.ndarray)
assert ar.get_dtype_name(x) == dtype
def test_triu(backend):
x = gen_rand((4, 4), backend)
xl = ar.do('triu', x)
xln = ar.to_numpy(xl)
assert xln[1, 0] == 0.0
if backend != 'sparse':
# this won't work for sparse because density < 1
assert (xln > 0.0).sum() == 10
xl = ar.do('triu', x, k=-1)
xln = ar.to_numpy(xl)
if backend != 'sparse':
# this won't work for sparse because density < 1
assert xln[1, 0] != 0.0
assert xln[2, 0] == 0.0
if backend != 'sparse':
# this won't work for sparse because density < 1
assert (xln > 0.0).sum() == 13
if backend == 'tensorflow':
with pytest.raises(ValueError):
ar.do('triu', x, 1)
def test_count_nonzero(backend, array_dtype):
if backend == 'mars':
import mars
if mars._version.version_info < (0, 4, 0, ''):
pytest.xfail('mars count_nonzero bug fixed in version 0.4.')
if array_dtype == 'int':
x = ar.do('array', [0, 1, 2, 0, 3], like=backend)
elif array_dtype == 'float':
x = ar.do('array', [0., 1., 2., 0., 3.], like=backend)
elif array_dtype == 'bool':
x = ar.do('array', [False, True, True, False, True], like=backend)
nz = ar.do('count_nonzero', x)
assert ar.to_numpy(nz) == 3
def cast_like(tensor1, tensor2):
"""Casts a tensor to the same dtype as another.
Args:
tensor1 (tensor_like): tensor to cast
tensor2 (tensor_like): tensor with corresponding dtype to cast to
Returns:
tensor_like: a tensor with the same shape and values as ``tensor1`` and the
same dtype as ``tensor2``
**Example**
>>> x = torch.tensor([1, 2])
>>> y = torch.tensor([3., 4.])
>>> cast_like(x, y)
tensor([1., 2.])
"""
dtype = ar.to_numpy(tensor2).dtype.type
return cast(tensor1, dtype)
def allclose(a, b, rtol=1e-05, atol=1e-08, **kwargs):
"""Wrapper around np.allclose, allowing tensors ``a`` and ``b``
to differ in type"""
t1 = ar.to_numpy(a)
t2 = ar.to_numpy(b)
return np.allclose(t1, t2, rtol=rtol, atol=atol, **kwargs)
