def test_almost_equal_shape():
shape1 = (2, 2, 3)
a = np.random.random(shape1)
b = a.copy()
c = a[1]
assert_almost_equal(a, b)
check_almost_euqal_expection_raise(a, c, "No exception raised")
def test_template_1type():
shape = (2, 3, 4)
for dtype in [np.int32, np.int64, np.float32, np.float64]:
a = mx.nd.random.uniform(0, 100, shape=shape).astype(dtype)
b = mx.nd.random.uniform(0, 100, shape=shape).astype(dtype)
c = mx.nd.empty(shape, dtype=dtype)
mobula.func.maximum(a.size, a, b, c)
assert_almost_equal(mx.nd.maximum(a, b).asnumpy(), c.asnumpy())
def test_template_3type():
shape = (2, 3, 4)
t1, t2, t3 = np.int32, np.float32, np.float64
a = mx.nd.random.uniform(0, 100, shape=shape).astype(t1)
b = mx.nd.random.uniform(0, 100, shape=shape).astype(t2)
c = mx.nd.empty(shape, dtype=t3)
mobula.func.maximum_3type(a.size, a, b, c)
assert_almost_equal(
mx.nd.maximum(a.astype(t2), b).asnumpy().astype(t3), c.asnumpy())
def test_default_value_op():
a = np.random.random((5, 5))
b = np.random.random((5, 5))
value = np.random.random((5, 5))
op = mobula.op.default_add_op[np.ndarray](value=value)
c = op(a, b)
assert_almost_equal(a + b, c)
c = op(a) # a+b[default=value]
assert_almost_equal(a + value, c)
def test_infer_type_for_const():
ns = [np.int32, np.int64, np.float32, np.float64]
N = 3
V = 39.39
for dtype in ns:
out = np.empty(N, dtype=dtype)
rv = dtype(V).tolist()
mobula.func.infer_type_for_const(N, rv, out)
assert_almost_equal(out, rv)
def test_const_template():
shape = (5, 5)
value = 3939
cs = [ctypes.c_int, ctypes.c_float, ctypes.c_double]
vs = [3, 9.9, 3.9]
for ctype, value in zip(cs, vs):
c_value = ctype(value)
a = np.empty(shape)
mobula.func.test_const_template(a.size, c_value, a)
assert_almost_equal(np.tile(value, shape), a)
def test_mobula_func():
# skip float temporarily
ns = [np.int32, np.int64] # , np.float32, np.float64]
pv = 39.39
for dtype in ns:
a = np.array([pv], dtype=dtype)
b = np.empty(a.shape, dtype=dtype)
rtn = mobula.func.set_and_return(a, b)
assert_almost_equal(a, b)
assert_almost_equal(a, rtn)
def test_thread():
n = 300
out_1 = np.empty(n // 1)
out_2 = np.empty(n // 2)
out_3 = np.empty(n // 3)
out_4 = np.empty(n * 2)
out_5 = np.empty(n * 3)
mobula.func.test_thread(n, out_1, out_2, out_3, out_4, out_5)
assert_almost_equal(np.arange(n // 1) * 1, out_1)
assert_almost_equal(np.arange(n // 2) * 2, out_2)
assert_almost_equal(np.arange(n // 3) * 3, out_3)
assert_almost_equal(np.arange(n * 2) * 2, out_4)
assert_almost_equal(np.arange(n * 3) * 3, out_5)
def test_non_c_contiguous():
a = np.random.random((5, 5))
b = np.random.random((5, 5))
c = np.empty((5, 5))
s = (slice(None), slice(2, 4))
a_part = a[s]
b_part = b[s]
c_part = c[s]
assert a_part.flags.c_contiguous == False
assert b_part.flags.c_contiguous == False
assert c_part.flags.c_contiguous == False
mobula.func.mul_elemwise(a_part.size, a_part, b_part, c_part)
assert_almost_equal(a_part * b_part, c_part)
assert_almost_equal(c[s], c_part)
def test_roi_align_value():
dtype = np.float32
dlen = 224
N, C, H, W = 5, 3, 16, 16
assert H == W
R = 7
pooled_size = (3, 4)
spatial_scale = H * 1.0 / dlen
sampling_ratio = 0
data = mx.nd.array(np.arange(N*C*W*H).reshape((N,C,H,W)), dtype = dtype)
# data = mx.nd.random.uniform(0, 1, (N, C, H, W), dtype = dtype)
center_xy = mx.nd.random.uniform(0, dlen, (R, 2), dtype = dtype)
wh = mx.nd.random.uniform(0, dlen, (R, 2), dtype = dtype)
batch_ind = mx.nd.array(np.random.randint(0, N, size = (R,1)))
pos = mx.nd.concat(center_xy - wh / 2, center_xy + wh / 2, dim = 1)
rois = mx.nd.concat(batch_ind, pos, dim = 1)
data.attach_grad()
rois.attach_grad()
with mx.autograd.record():
output = mobula.op.ROIAlign(data = data, rois = rois, pooled_size = pooled_size, spatial_scale = spatial_scale, sampling_ratio = sampling_ratio)
dy = mx.nd.random.uniform(-1, 1, (R, C) + pooled_size, dtype = dtype)
output.backward(dy)
real_output, [dx, drois] = roialign_forward_backward(data.asnumpy(), rois.asnumpy(), pooled_size, spatial_scale, sampling_ratio, dy.asnumpy())
bottom_diff = np.zeros(data.shape, dtype = T)
roialign_backward(bottom_diff, rois.asnumpy(), pooled_size, spatial_scale, sampling_ratio, dy.asnumpy())
assert_almost_equal(dx, bottom_diff)
assert_almost_equal(output.asnumpy(), real_output, atol = 1e-3)
assert_almost_equal(data.grad.asnumpy(), dx, atol = 1e-3)
assert_almost_equal(rois.grad.asnumpy(), drois, atol = 1e-3)
def test_ctx_np():
shape = (5, 5)
a = np.random.random(shape)
b = np.random.random(shape)
dy = np.random.random(shape)
op = MulOP[np.ndarray]()
c = op.forward(a, b)
a_grad, b_grad = op.backward(dy)
assert_almost_equal(a_grad, b * dy)
assert_almost_equal(b_grad, a * dy)
assert_almost_equal(a * b, c)
def test_almost_equal_value():
shape1 = (2, 2, 3)
a = np.random.random(shape1)
b = a.copy()
atol = 1e-3
assert_almost_equal(a, b, atol=0)
assert_almost_equal(a, b, atol=atol)
b[0, 0, 0] += atol
b[0, 1, 2] -= atol
assert_almost_equal(a, b, rtol=np.inf, atol=atol * 2.0)
check_almost_euqal_expection_raise(a,
b,
'Absolute Error Check failed',
rtol=np.inf,
atol=atol / 2.0)
eps = np.finfo(b.dtype).eps
rtol = np.max(np.abs((a - b) / (b + eps)))
assert_almost_equal(a, b, rtol=rtol * 2.0, atol=atol * 2.0)
check_almost_euqal_expection_raise(a,
b,
'Relative Error Check failed',
rtol=rtol * 2.0,
atol=atol / 2.0)
def test_ctx_torch():
try:
import torch
except ImportError:
return
shape = (5, 5)
a_np = np.random.random(shape)
b_np = np.random.random(shape)
dy_np = np.random.random(shape)
a = torch.tensor(a_np, requires_grad=True)
b = torch.tensor(b_np, requires_grad=True)
dy = torch.tensor(dy_np)
c = MulOP(a, b)
c.backward(dy)
assert_almost_equal(a.grad.data, (b * dy).data)
assert_almost_equal(b.grad.data, (a * dy).data)
assert_almost_equal((a * b).data, c.data)
def test_ctx_mxnet():
try:
import mxnet as mx
except ImportError:
return
shape = (5, 5)
a_np = np.random.random(shape)
b_np = np.random.random(shape)
dy_np = np.random.random(shape)
a = mx.nd.array(a_np)
b = mx.nd.array(b_np)
dy = mx.nd.array(dy_np)
a.attach_grad()
b.attach_grad()
with mx.autograd.record():
c = MulOP(a, b)
c.backward(dy)
assert_almost_equal(a.grad, b * dy)
assert_almost_equal(b.grad, a * dy)
assert_almost_equal(a * b, c)
def test_func_kwargs():
a = np.random.random((5, 5))
b = np.random.random((5, 5))
c = np.empty((5, 5))
mobula.func.mul_elemwise(n=a.size, a=a, b=b, c=c)
assert_almost_equal(a * b, c)
def check_almost_euqal_expection_raise(a, b, info, rtol=1e-5, atol=1e-8):
try:
assert_almost_equal(a, b, rtol=rtol, atol=atol)
raise Exception(info)
except AssertionError:
pass
