def test_Gemm2D_float_2(self):
shape_a = (8, 6)
shape_b = (8, 6)
shape_c = (8, 8)
transA = 0
transB = 1
np_float_a = np.reshape(self.np_float_a, shape_a)
np_float_b = np.reshape(self.np_float_b, shape_b)
np_float_c = np.reshape(self.np_float_c, shape_c)
dc_float_a = dc.reshape(self.dc_float_a, shape_a)
dc_float_b = dc.reshape(self.dc_float_b, shape_b)
dc_float_c = dc.reshape(self.dc_float_c, shape_c)
npr = temp_gemm(np_float_a, np_float_b, np_float_c, self.alpha,
self.beta, transA, transB)
dcr = dc.gemm(dc_float_a, dc_float_b, dc_float_c, self.alpha,
self.beta, transA, transB)
np.testing.assert_allclose(npr.flatten(),
np.array(dcr.data()).astype(np.float32),
rtol=1e-3,
atol=1e-3)
def test_Gemm2D_double_3(self):
shape_a = (6, 8)
shape_b = (6, 8)
shape_c = (8, 8)
transA = 1
transB = 0
np_double_a = np.reshape(self.np_double_a, shape_a)
np_double_b = np.reshape(self.np_double_b, shape_b)
np_double_c = np.reshape(self.np_double_c, shape_c)
dc_double_a = dc.reshape(self.dc_double_a, shape_a)
dc_double_b = dc.reshape(self.dc_double_b, shape_b)
dc_double_c = dc.reshape(self.dc_double_c, shape_c)
npr = temp_gemm(np_double_a, np_double_b, np_double_c, self.alpha,
self.beta, transA, transB)
dcr = dc.gemm(dc_double_a, dc_double_b, dc_double_c, self.alpha,
self.beta, transA, transB)
np.testing.assert_allclose(npr.flatten(),
np.array(dcr.data()).astype(np.double),
rtol=1e-3,
atol=1e-3)
def test_Hardmax2D_2(self):
np_a = np.reshape(self.np_a, (3, 8))
dc_a = dc.reshape(self.dc_a, (3, 8))
self.coerce(np_a)
np_a = np.reshape(np_a, (self.axis1, self.axis2))
npr = (np_a.max(0, keepdims=1) == np_a).astype(float)
dcr = dc.hardmax(dc_a, self.axis)
np.testing.assert_allclose(npr.flatten(),
np.array(dcr.data()).astype(np.float32),
rtol=1e-3,
atol=1e-3)
def test_Flatten2D_bool(self):
axis = 2
shape = (8, 6)
np_bool_a = np.reshape(self.np_bool_a, shape)
dc_bool_a = dc.reshape(self.dc_bool_a, shape)
npr = temp_flatten(np_bool_a, shape, axis)
dcr = dc.flatten(dc_bool_a, axis)
np.testing.assert_allclose(npr.flatten(),
np.array(dcr.data()).astype(np.bool),
rtol=1e-3,
atol=1e-3)
np.testing.assert_equal(npr.shape, dcr.shape())
def test_Flatten4D_double(self):
axis = 3
shape = (4, 2, 2, 3)
np_double_a = np.reshape(self.np_double_a, shape)
dc_double_a = dc.reshape(self.dc_double_a, shape)
npr = temp_flatten(np_double_a, shape, axis)
dcr = dc.flatten(dc_double_a, axis)
np.testing.assert_allclose(npr.flatten(),
np.array(dcr.data()).astype(np.float64),
rtol=1e-3,
atol=1e-3)
np.testing.assert_equal(npr.shape, dcr.shape())
def test_Flatten3D_float(self):
axis = 2
shape = (4, 4, 3)
np_float_a = np.reshape(self.np_float_a, shape)
dc_float_a = dc.reshape(self.dc_float_a, shape)
npr = temp_flatten(np_float_a, shape, axis)
dcr = dc.flatten(dc_float_a, axis)
np.testing.assert_allclose(npr.flatten(),
np.array(dcr.data()).astype(np.float32),
rtol=1e-3,
atol=1e-3)
np.testing.assert_equal(npr.shape, dcr.shape())
def test_GlobalMaxPool4D_1(self):
np_a = np.reshape(self.np_a, (2, 2, 2, 3))
dc_a = dc.reshape(self.dc_a, (2, 2, 2, 3))
spatial_shape = np.ndim(np_a) - 2
npr = np.max(np_a, axis=tuple(range(2, spatial_shape + 2)))
for _ in range(spatial_shape):
npr = np.expand_dims(npr, -1)
dcr = dc.global_max_pool(dc_a)
np.testing.assert_allclose(npr.flatten(),
np.array(dcr.data()).astype(np.float32),
rtol=1e-3,
atol=1e-3)
def test_Softmax2D(self):
np_a = np.reshape(self.np_a, (6, 4))
dc_a = dc.reshape(self.dc_a, (6, 4))
self.coerce(np_a)
np_a = np.reshape(np_a, (self.axis1, self.axis2))
npr = softmax_2d(np_a)
dcr = dc.softmax(dc_a, self.axis)
np.testing.assert_allclose(npr.flatten(),
np.array(dcr.data()).astype(np.float32),
rtol=1e-3,
atol=1e-3)
def test_error_message(self):
dc_a = dc.reshape(self.dc_a, (2, 5, 2))
dc_b = dc.reshape(self.dc_b, (4, 5, 2))
np_a = np.reshape(self.np_a, (2, 5, 2))
np_b = np.reshape(self.np_b, (4, 5, 2))
try:
np_sum = np.add(np_a, np_b)
except:
type, val, tb = sys.exc_info()
np_err = val.__str__()
assert (np_err[0:65] == self.err[0:65]
), "ASSERT FAILED for numpy error message"
try:
dc_sum = dc.add(dc_a, dc_b)
except:
type, val, tb = sys.exc_info()
dc_err = val.__str__()
assert (dc_err[0:65] == self.err[0:65]
), "ASSERT FAILED for dc error message"
assert (dc_err[0:65] == np_err[0:65]
), "ASSERT FAILED for matching numpy and dc error message"
def test_GlobalAveragePool2D (self):
np_a = np.reshape(self.np_a, (4,6))
dc_a = dc.reshape(self.dc_a, (4,6))
if(np.ndim(np_a)<=2):
npr = np_a
else:
spatial_shape = np.ndim(np_a) -2
npr = np.average(np_a, axis=tuple(range(2, spatial_shape + 2)))
for _ in range(spatial_shape):
npr = np.expand_dims(npr, -1)
dcr = dc.global_average_pool(dc_a)
np.testing.assert_allclose(npr.flatten(), np.array(dcr.data()).astype(np.float32),
rtol=1e-3, atol=1e-3)
def test_GlobalLpPool3D_3(self):
np_a = np.reshape(self.np_a, (8, 1, 3))
dc_a = dc.reshape(self.dc_a, (8, 1, 3))
np_a = np.reshape(np_a, (np_a.shape[0], np_a.shape[1], end_axis(np_a)))
npr = np.linalg.norm(np_a, ord=self.p, axis=2)
spatial_shape = np.ndim(np_a) - 2
for _ in range(spatial_shape):
npr = np.expand_dims(npr, -1)
dcr = dc.global_lp_pool(dc_a, self.p)
np.testing.assert_allclose(npr.flatten(),
np.array(dcr.data()).astype(np.float32),
rtol=1e-3,
atol=1e-3)
def setUp(self):
self.num_directions = 1
self.seq_length = 1
self.input_size = 4
self.batch_size = 3
self.hidden_size = 5
self.np_x = np.random.randn(self.seq_length * self.batch_size * self.input_size).astype(np.float32)
self.dc_x = dc.array(list(self.np_x))
self.np_w = np.random.randn(self.num_directions * 4 * self.hidden_size * self.input_size).astype(np.float32)
self.dc_w = dc.array(list(self.np_w))
self.np_r = np.random.randn(self.num_directions * 4 * self.hidden_size * self.hidden_size).astype(np.float32)
self.dc_r = dc.array(list(self.np_r))
self.np_b = np.random.randn(self.num_directions * 8 * self.hidden_size).astype(np.float32)
self.dc_b = dc.array(list(self.np_b))
self.np_h = np.random.randn(self.num_directions * self.batch_size * self.hidden_size).astype(np.float32)
self.dc_h = dc.array(list(self.np_h))
self.np_c = np.random.randn(self.num_directions * self.batch_size * self.hidden_size).astype(np.float32)
self.dc_c = dc.array(list(self.np_c))
self.np_p = np.random.randn(self.num_directions * 3 * self.hidden_size).astype(np.float32)
self.dc_p = dc.array(list(self.np_p))
self.np_x = np.reshape(self.np_x, (self.seq_length, self.batch_size, self.input_size))
self.dc_x = dc.reshape(self.dc_x, (self.seq_length, self.batch_size, self.input_size))
self.np_w = np.reshape(self.np_w, (self.num_directions, 4 * self.hidden_size, self.input_size))
self.dc_w = dc.reshape(self.dc_w, (self.num_directions, 4 * self.hidden_size, self.input_size))
self.np_r = np.reshape(self.np_r, (self.num_directions, 4 * self.hidden_size, self.hidden_size))
self.dc_r = dc.reshape(self.dc_r, (self.num_directions, 4 * self.hidden_size, self.hidden_size))
self.np_b = np.reshape(self.np_b, (self.num_directions, 8 * self.hidden_size))
self.dc_b = dc.reshape(self.dc_b, (self.num_directions, 8 * self.hidden_size))
self.np_h = np.reshape(self.np_h, (self.num_directions, self.batch_size, self.hidden_size))
self.dc_h = dc.reshape(self.dc_h, (self.num_directions, self.batch_size, self.hidden_size))
self.np_c = np.reshape(self.np_c, (self.num_directions, self.batch_size, self.hidden_size))
self.dc_c = dc.reshape(self.dc_c, (self.num_directions, self.batch_size, self.hidden_size))
self.np_p = np.reshape(self.np_p, (self.num_directions, 3 * self.hidden_size))
self.dc_p = dc.reshape(self.dc_p, (self.num_directions, 3 * self.hidden_size))
def test_Slice4D(self):
len = np.sqrt(np.sqrt(self.len)).astype(int)
np_a = np.reshape(self.np_a, (len, len, len, len))
# dc_a = dc.reshape(self.dc_a, (len, len, len))
dc_a = dc.reshape(self.dc_a, (8, 8, 8, 8))
np_start = np.random.randint(len / 2)
np_end = np.random.randint(len / 2 + 1, len)
np_step = np.random.randint(1, len - 1)
np_axes = 1
np_start2 = np.random.randint(len / 2)
np_end2 = np.random.randint(len / 2 + 1, len)
np_step2 = np.random.randint(1, len - 1)
np_axes2 = 2
np_start3 = np.random.randint(len / 2)
np_end3 = np.random.randint(len / 2 + 1, len)
np_step3 = np.random.randint(1, len - 1)
np_axes3 = 3
np_start4 = np.random.randint(len / 2)
np_end4 = np.random.randint(len / 2 + 1, len)
np_step4 = np.random.randint(1, len - 1)
np_axes4 = 4
dc_start = dc.array(4).asTypeULong()
dc_end = dc.array(4).asTypeULong()
dc_axes = dc.array(4).asTypeInt()
dc_step = dc.array(4).asTypeULong()
dc_start[0] = np_start
dc_end[0] = np_end
dc_axes[0] = np_axes
dc_step[0] = np_step
dc_start[1] = np_start2
dc_end[1] = np_end2
dc_axes[1] = np_axes2
dc_step[1] = np_step2
dc_start[2] = np_start3
dc_end[2] = np_end3
dc_axes[2] = np_axes3
dc_step[2] = np_step3
dc_start[3] = np_start4
dc_end[3] = np_end4
dc_axes[3] = np_axes4
dc_step[3] = np_step4
npr = np_a[np_start:np_end:np_step, np_start2:np_end2:np_step2,
np_start3:np_end3:np_step3, np_start4:np_end4:np_step4]
dcr = dc.slice(dc_a, dc_start, dc_end, dc_axes, dc_step)
np.testing.assert_allclose(npr.flatten(),
np.array(dcr.data()).astype(np.float32),
rtol=1e-3,
atol=1e-3)
def test_LRN3D_2(self):
np_a = np.reshape(self.np_a, (2, 2, 6))
dc_a = dc.reshape(self.dc_a, (2, 2, 6))
square_sum = np.zeros((2, 2, 6)).astype(np.float32)
for n, c, h in np.ndindex(np_a.shape):
square_sum[n, c, h] = sum(
np_a[n,
max(0, c - int(math.floor((self.size - 1) / 2))
):min(5, c + int(math.ceil((self.size - 1) / 2)) + 1),
h]**2)
npr = np_a / ((self.bias +
(self.alpha / self.size) * square_sum)**self.beta)
dcr = dc.lrn(dc_a, self.size, self.alpha, self.beta, self.bias)
np.testing.assert_allclose(npr.flatten(),
np.array(dcr.data()).astype(np.float32),
rtol=1e-3,
atol=1e-3)
def test_ReduceL2_3D(self):
np_a = np.reshape(self.np_a, (2, 4, 3))
dc_a = dc.reshape(self.dc_a, (2, 4, 3))
npr = np.sqrt(np.sum(a=np.square(np_a), axis=(0), keepdims=False))
dcr = dc.reduce_L2(dc_a, [0])
np.testing.assert_allclose(npr.flatten(),
np.array(dcr.data()).astype(np.float32),
rtol=1e-3,
atol=1e-3)
npr2 = np.sqrt(np.sum(a=np.square(np_a), axis=(0, 2), keepdims=False))
dcr2 = dc.reduce_L2(dc_a, [0, 2])
np.testing.assert_allclose(npr2.flatten(),
np.array(dcr2.data()).astype(np.float32),
rtol=1e-3,
atol=1e-3)
npr3 = np.sqrt(
np.sum(a=np.square(np_a), axis=(0, 1, 2), keepdims=False))
dcr3 = dc.reduce_L2(dc_a, [])
np.testing.assert_allclose(npr3.flatten(),
np.array(dcr3.data()).astype(np.float32),
rtol=1e-3,
atol=1e-3)
npr4 = np.sqrt(np.sum(a=np.square(np_a), axis=(0), keepdims=True))
dcr4 = dc.reduce_L2(dc_a, [0], 1)
np.testing.assert_allclose(npr4.flatten(),
np.array(dcr4.data()).astype(np.float32),
rtol=1e-3,
atol=1e-3)
npr5 = np.sqrt(np.sum(a=np.square(np_a), axis=(0, 1, 2),
keepdims=True))
dcr5 = dc.reduce_L2(dc_a, [], 1)
np.testing.assert_allclose(npr5.flatten(),
np.array(dcr5.data()).astype(np.float32),
rtol=1e-3,
atol=1e-3)
def test_Slice3D (self):
len = np.cbrt(self.len).astype(int)
np_a = np.reshape(self.np_a, (len, len, len))
# dc_a = dc.reshape(self.dc_a, (len, len, len))
dc_a = dc.reshape(self.dc_a, (16, 16, 16))
np_start = np.random.randint(len/2)
np_end = np.random.randint(len/2 + 1, len)
np_step = np.random.randint(1, len-1)
np_axes = 0
np_start2 = np.random.randint(len/2)
np_end2 = np.random.randint(len/2 + 1, len)
np_step2 = np.random.randint(1, len-1)
np_axes2 = 1
np_start3 = np.random.randint(len/2)
np_end3 = np.random.randint(len/2 + 1, len)
np_step3 = np.random.randint(1, len-1)
np_axes3 = 2
dc_start = dc.array(3).asTypeInt()
dc_end = dc.array(3).asTypeInt()
dc_axes = dc.array(3).asTypeInt()
dc_step = dc.array(3).asTypeInt()
dc_start[0] = np_start
dc_end[0] = np_end
dc_axes[0] = np_axes
dc_step[0] = np_step
dc_start[1] = np_start2
dc_end[1] = np_end2
dc_axes[1] = np_axes2
dc_step[1] = np_step2
dc_start[2] = np_start3
dc_end[2] = np_end3
dc_axes[2] = np_axes3
dc_step[2] = np_step3
npr = np_a[np_start:np_end:np_step, np_start2:np_end2:np_step2, np_start3:np_end3:np_step3]
dcr = dc.slice(dc_a, dc_start, dc_end, dc_axes, dc_step)
np.testing.assert_allclose(npr.flatten(), np.array(dcr.data()).astype(np.float32),
rtol=1e-3, atol=1e-3)
def test_non_binary():
t1 = dc.array(2, 3)
t2 = dc.array(3, 2)
mul = dc.matmul(t1, t2)
#print ("multiplication : " , mul.to_string())
t3 = dc.array(2, 3, 4)
#print("old shape", t1.shape())
new_shape = dc.vectorSizeT([2, 12])
t3.reshape(new_shape)
t3.reshape(4, 6)
t3.reshape((4, 6))
t3.reshape([4, 6])
#print("new shape", t1.shape())
py_list = list(t3)
# convert tensor to python list
py_tuple = tuple(t3)
# convert tensor to python tuple
np_ary = t3.numpy()
# convert to numpy array
#t4 = dc.thresholded_relu(t1);
#print("relu", t4.to_string())
#replace first few values in tensor with new values.
data = dc.vectorFloat([1.0, 2.0, 3.0, 4.0])
t3.load(data)
#print(t3.to_string())
arr = dc.array([1, 2])
#print(arr)
arr2D = dc.array([[1, 2], [10, 20]]).asTypeInt()
#print(arr2D)
arrRand = dc.random(2, 3)
#print(arrRand)
empty = dc.empty(3, 2)
#print(empty)
zeros = dc.zeros(2, 2)
#print(zeros);
ones = dc.ones(2, 2)
#print(ones)
ranges = dc.arange(15, 3, 2)
#print(ranges)
dc.reshape(arr2D, (1, 4))
#3D MatMul Test1
a = dc.array(2, 2, 2)
b = dc.array(2, 2, 2)
adata = dc.vectorFloat([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0])
bdata = dc.vectorFloat([8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0])
a.load(adata)
b.load(bdata)
test_multiply(a, b)
#3D MatMul Test2
a = dc.array(2, 2, 3)
b = dc.array(2, 3, 2)
adata = dc.vectorFloat(
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0])
bdata = dc.vectorFloat(
[12.0, 11.0, 10.0, 9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0])
a.load(adata)
b.load(bdata)
test_multiply(a, b)
def test_IsNaN2D_3 (self):
np_a = np.reshape(self.np_a, (12,2))
dc_a = dc.reshape(self.dc_a, (12,2))
npr = np.isnan(np_a)
dcr = dc.isnan(dc_a)
np.testing.assert_array_equal(npr.flatten(), np.array(dcr.data()))
def test_IsInf2D_3(self):
np_a = np.reshape(self.np_a, (12, 2))
dc_a = dc.reshape(self.dc_a, (12, 2))
npr = Isinf(np_a, self.detect_positive, self.detect_negative)
dcr = dc.isinf(dc_a, self.detect_positive, self.detect_negative)
np.testing.assert_array_equal(npr.flatten(), np.array(dcr.data()))
def setUp(self):
## random testcase
self.channels = 1
self.featuremaps = 1
self.batchsize = 1
#self.oneK = 1024
self.oneK = 50
self.X_h = self.oneK + np.random.randint(self.oneK * 3)
self.X_w = self.oneK + np.random.randint(self.oneK * 3)
self.K_h = 3 + np.random.randint(97)
self.K_w = 3 + np.random.randint(97)
self.np_strides = np.zeros(2).astype(np.float32)
self.np_strides[0] = 1 + np.random.randint(self.K_w - 1)
self.np_strides[1] = 1 + np.random.randint(self.K_h - 1)
self.np_B = np.zeros(self.featuremaps).astype(np.float32)
self.np_X_data = np.random.randn(self.X_w * self.X_h).astype(
np.float32)
self.np_K_data = np.random.randn(self.K_w * self.K_h).astype(
np.float32)
self.np_X = np.reshape(self.np_X_data, (self.X_h, self.X_w))
self.np_K = np.reshape(self.np_K_data, (self.K_h, self.K_w))
self.dc_X = dc.reshape(
dc.array(list(self.np_X_data)),
(self.batchsize, self.channels, self.X_h, self.X_w)).asTypeFloat()
self.dc_K = dc.reshape(dc.array(list(self.np_K_data)),
(self.featuremaps, self.channels, self.K_h,
self.K_w)).asTypeFloat()
self.dc_B = dc.zeros(self.featuremaps).asTypeFloat()
self.dc_strides = dc.reshape(dc.array(list(self.np_strides)),
(2)).asTypeInt()
self.dc_nullT = dc.array(0)
## onnx conv example testcase
self.onnx_dc_X = dc.reshape(
dc.array([
0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13.,
14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.
]), (1, 1, 5, 5))
self.onnx_dc_X2 = dc.reshape(
dc.array([
0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13.,
14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25.,
26., 27., 28., 29., 30., 31., 32., 33., 34.
]), (1, 1, 7, 5))
self.onnx_dc_W = dc.reshape(
dc.array([1., 1., 1., 1., 1., 1., 1., 1., 1.]), (1, 1, 3, 3))
self.onnx_npr_su = np.array([
12., 21., 27., 33., 24., 33., 54., 63., 72., 51., 63., 99., 108.,
117., 81., 93., 144., 153., 162., 111., 72., 111., 117., 123., 84.
])
self.onnx_npr_vl = np.array(
[54., 63., 72., 99., 108., 117., 144., 153., 162.])
self.onnx_npr_vl_s2 = np.array([54., 72., 144., 162., 234., 252.])
self.onnx_npr_sp_s2 = np.array([
12., 27., 24., 63., 108., 81., 123., 198., 141., 112., 177., 124.
])
self.onnx_npr_ap_s2 = np.array(
[21., 33., 99., 117., 189., 207., 171., 183.])
self.onnx_dc_BIGW = dc.reshape(dc.array(list(np.ones(900))),
(1, 1, 30, 30))
def MatMul3D (self):
dc_a = dc.reshape(self.dc_a, (self.N, self.N))
dc_b = dc.reshape(self.dc_b, (self.N, self.N))
dcr = dc.matmul(dc_a, dc_b);
