def test_group_convolution_operator():
runtime = get_runtime()
data_shape = [1, 4, 2, 2]
filters_shape = [2, 1, 2, 1, 1]
parameter_data = ng.parameter(data_shape, name='Data', dtype=np.float32)
parameter_filters = ng.parameter(filters_shape,
name='Filters',
dtype=np.float32)
data_value = np.arange(start=1.0, stop=17.0,
dtype=np.float32).reshape(data_shape)
filters_value = np.arange(start=1.0, stop=5.0,
dtype=np.float32).reshape(filters_shape)
strides = [1, 1]
dilations = [1, 1]
pads_begin = [0, 0]
pads_end = [0, 0]
model = ng.group_convolution(parameter_data, parameter_filters, strides,
pads_begin, pads_end, dilations)
computation = runtime.computation(model, parameter_data, parameter_filters)
result = computation(data_value, filters_value)
expected = np.array([11, 14, 17, 20, 79, 86, 93, 100],
dtype=np.float32).reshape(1, 2, 2, 2)
assert np.allclose(result, expected)
def test_gemm_operator():
runtime = get_runtime()
shape_a = [3, 2]
shape_b = [3, 2]
shape_c = [2, 1]
value_a = np.array([[1, 2], [3, 4], [5, 6]], dtype=np.float32)
value_b = np.array([[1, 2], [3, 4], [5, 6]], dtype=np.float32)
value_c = np.array([[13], [14]], dtype=np.float32)
parameter_a = ng.parameter(shape_a, name='A', dtype=np.float32)
parameter_b = ng.parameter(shape_b, name='B', dtype=np.float32)
parameter_c = ng.parameter(shape_c, name='C', dtype=np.float32)
alpha_value = np.float32(3)
beta_value = np.float32(3)
transA = True
transB = False
model = ng.gemm(parameter_a, parameter_b, parameter_c, alpha_value, beta_value, transA, transB)
computation = runtime.computation(model, parameter_a, parameter_b, parameter_c)
result = computation(value_a, value_b, value_c)
# expected = value_alpha * value_a' * value_b + value_beta * value_c
value_a = value_a.transpose()
a_mul_a = np.multiply(alpha_value, value_a)
aa_mul_b = np.dot(a_mul_a, value_b)
b_mul_c = np.dot(beta_value, value_c)
expected = np.add(aa_mul_b, b_mul_c)
assert np.allclose(result, expected)
def test_lrn():
input_image_shape = (2, 3, 2, 1)
input_image = np.arange(int(
np.prod(input_image_shape))).reshape(input_image_shape).astype('f')
runtime = get_runtime()
model = ng.lrn(ng.constant(input_image),
alpha=1.0,
beta=2.0,
bias=1.0,
size=3)
computation = runtime.computation(model)
result = computation()
assert np.allclose(
result,
np.array([[[[0.0], [0.05325444]], [[0.03402646], [0.01869806]],
[[0.06805293], [0.03287071]]],
[[[0.00509002], [0.00356153]], [[0.00174719], [0.0012555]],
[[0.00322708], [0.00235574]]]],
dtype=np.float32))
# Test LRN default parameter values
model = ng.lrn(ng.constant(input_image))
computation = runtime.computation(model)
result = computation()
assert np.allclose(
result,
np.array([[[[0.0], [0.35355338]], [[0.8944272], [1.0606602]],
[[1.7888544], [1.767767]]],
[[[0.93704253], [0.97827977]], [[1.2493901], [1.2577883]],
[[1.5617375], [1.5372968]]]],
dtype=np.float32))
def test_group_convolution_backprop_data_output_shape():
runtime = get_runtime()
data_shape = [1, 1, 1, 10]
filters_shape = [1, 1, 1, 1, 5]
strides = [1, 1]
data_node = ng.parameter(data_shape, name='Data', dtype=np.float32)
filters_node = ng.parameter(filters_shape,
name='Filters',
dtype=np.float32)
output_shape_node = ng.constant(np.array([1, 14], dtype=np.int64))
model = ng.group_convolution_backprop_data(data_node,
filters_node,
strides,
output_shape_node,
auto_pad='same_upper')
data_value = np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0],
dtype=np.float32).reshape(data_shape)
filters_value = np.array([1.0, 2.0, 3.0, 2.0, 1.0],
dtype=np.float32).reshape(filters_shape)
computation = runtime.computation(model, data_node, filters_node)
result = computation(data_value, filters_value)
expected = np.array([
0.0, 1.0, 4.0, 10.0, 18.0, 27.0, 36.0, 45.0, 54.0, 63.0, 62.0, 50.0,
26.0, 9.0
],
dtype=np.float32).reshape(1, 1, 1, 14)
assert np.allclose(result, expected)
def test_shuffle_channels_operator():
runtime = get_runtime()
data_shape = [1, 15, 2, 2]
axis = 1
groups = 5
parameter = ng.parameter(data_shape, name='Data', dtype=np.float32)
data_value = np.arange(60., dtype=np.float32).reshape(data_shape)
model = ng.shuffle_channels(parameter, axis, groups)
computation = runtime.computation(model, parameter)
result = computation(data_value)
expected = np.array([[[[0., 1.], [2., 3.]], [[12., 13.], [14., 15.]],
[[24., 25.], [26., 27.]], [[36., 37.], [38., 39.]],
[[48., 49.], [50., 51.]], [[4., 5.], [6., 7.]],
[[16., 17.], [18., 19.]], [[28., 29.], [30., 31.]],
[[40., 41.], [42., 43.]], [[52., 53.], [54., 55.]],
[[8., 9.], [10., 11.]], [[20., 21.], [22., 23.]],
[[32., 33.], [34., 35.]], [[44., 45.], [46., 47.]],
[[56., 57.], [58., 59.]]]],
dtype=np.float32)
assert np.allclose(result, expected)
def test_group_convolution_operator():
runtime = get_runtime()
data_shape = [1, 4, 2, 2]
filters_shape = [2, 2, 1, 1]
parameter_data = ng.parameter(data_shape, name='Data', dtype=np.float32)
parameter_filters = ng.parameter(filters_shape, name='Filters', dtype=np.float32)
data_value = np.arange(start=1.0, stop=17.0, dtype=np.float32).reshape(data_shape)
filters_value = np.arange(start=1.0, stop=5.0, dtype=np.float32).reshape(filters_shape)
window_movement_strides = [1, 1]
window_dilation_strides = [1, 1]
padding_below = [0, 0]
padding_above = [0, 0]
data_dilation_strides = [1, 1]
groups = 2
model = ng.group_convolution(parameter_data,
parameter_filters,
window_movement_strides,
window_dilation_strides,
padding_below, padding_above,
data_dilation_strides,
groups,
0)
computation = runtime.computation(model, parameter_data, parameter_filters)
result = computation(data_value, filters_value)
expected = np.array([11, 14, 17, 20, 79, 86, 93, 100],
dtype=np.float32).reshape(1, 2, 2, 2)
assert np.allclose(result, expected)
def test_max_pool_same_lower_auto_pads():
rt = get_runtime()
# array([[[[ 0.5, 1.5, 2.5, 3.5],
# [ 4.5, 5.5, 6.5, 7.5],
# [ 8.5, 9.5, 10.5, 11.5],
# [12.5, 13.5, 14.5, 15.5]]]], dtype=float32)
data = np.arange(0.5, 16, dtype=np.float32).reshape((1, 1, 4, 4))
strides = [1, 1]
pads_begin = [0, 0]
pads_end = [0, 0]
# 0 0 , 0 , 0 , 0,
# 0 [ 0.5, 1.5, 2.5, 3.5],
# 0 [ 4.5, 5.5, 6.5, 7.5],
# 0 [ 8.5, 9.5, 10.5, 11.5],
# 0 [12.5, 13.5, 14.5, 15.5],
kernel_shape = [2, 2]
auto_pad = 'same_lower'
data_node = ng.parameter(data.shape, name='A', dtype=np.float32)
avgpool_node = ng.max_pool(data_node, strides, pads_begin, pads_end, kernel_shape,
auto_pad=auto_pad)
comp = rt.computation(avgpool_node, data_node)
result = comp(data)
expected = np.array([[[[0.5, 1.5, 2.5, 3.5],
[4.5, 5.5, 6.5, 7.5],
[8.5, 9.5, 10.5, 11.5],
[12.5, 13.5, 14.5, 15.5]]]], dtype=np.float32)
assert np.allclose(result, expected)
def test_grn_operator():
runtime = get_runtime()
data_value = np.arange(start=1.0, stop=25.0,
dtype=np.float32).reshape(1, 2, 3, 4)
bias = np.float32(1e-6)
data_shape = [1, 2, 3, 4]
parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32)
model = ng.grn(parameter_data, bias)
computation = runtime.computation(model, parameter_data)
result = computation(data_value)
expected = np.array(
[[
[
[0.0766965, 0.14142136, 0.19611613, 0.24253564],
[0.28216633, 0.31622776, 0.34570536, 0.37139067],
[0.39391932, 0.41380295, 0.4314555, 0.4472136],
],
[
[0.9970545, 0.98994946, 0.9805807, 0.97014254],
[0.9593655, 0.9486833, 0.9383431, 0.9284767],
[0.91914505, 0.9103665, 0.9021342, 0.8944272],
],
]],
dtype=np.float32,
)
assert np.allclose(result, expected)
def test_dequantize_operator():
runtime = get_runtime()
data_shape = [4, 3]
scale_shape = []
zero_point_shape = []
result_shape = [4, 3]
data_value = np.array([1, 1, 2, -1, 3, -1, 4, -3, 5, -3, 6,
-5]).astype(np.int8).reshape(data_shape)
scale_value = np.float32(2)
zero_point_value = np.int8(1)
element_type = np.float32
axis_set = []
parameter_data = ng.parameter(data_shape, name='Data', dtype=np.int8)
parameter_scale = ng.parameter(scale_shape, name='Scale', dtype=np.float32)
parameter_zero_point = ng.parameter(zero_point_shape,
name='Zero_Point',
dtype=np.int8)
model = ng.dequantize(parameter_data, parameter_scale,
parameter_zero_point, element_type, axis_set)
computation = runtime.computation(model, parameter_data, parameter_scale,
parameter_zero_point)
result = computation(data_value, scale_value, zero_point_value)
expected = np.array([0, 0, 2, -4, 4, -4, 6, -8, 8, -8, 10,
-12]).astype(np.float32).reshape(result_shape)
assert np.allclose(result, expected)
def test_quantize_operator():
runtime = get_runtime()
data_shape = [6]
scale_shape = []
zero_point_shape = []
data_value = np.array([0, 2, 3, 1000, -254, -1000]).astype(np.float32)
scale_value = np.float32(2)
zero_point_value = np.uint8(128)
new_type = np.uint8
axis_set = []
parameter_data = ng.parameter(data_shape, name='Data', dtype=np.float32)
parameter_scale = ng.parameter(scale_shape, name='Scale', dtype=np.float32)
parameter_zero_point = ng.parameter(zero_point_shape,
name='Zero_Point',
dtype=np.uint8)
model = ng.quantize(parameter_data, parameter_scale, parameter_zero_point,
new_type, axis_set,
Quantize.RoundMode.ROUND_NEAREST_TOWARD_INFINITY)
computation = runtime.computation(model, parameter_data, parameter_scale,
parameter_zero_point)
result = computation(data_value, scale_value, zero_point_value)
expected = np.array([128, 129, 130, 255, 1, 0]).astype(np.uint8)
assert np.allclose(result, expected)
def test_mvn_operator():
runtime = get_runtime()
data_shape = [3, 3, 3, 1]
axis = [0, 2, 3]
normalize_variance = True
eps = np.float32(1e-9)
data_value = np.array([[[[0.8439683], [0.5665144], [0.05836735]],
[[0.02916367], [0.12964272], [0.5060197]],
[[0.79538304], [0.9411346], [0.9546573]]],
[[[0.17730942], [0.46192095], [0.26480448]],
[[0.6746842], [0.01665257], [0.62473077]],
[[0.9240844], [0.9722341], [0.11965699]]],
[[[0.41356155], [0.9129373], [0.59330076]],
[[0.81929934], [0.7862604], [0.11799799]],
[[0.69248444], [0.54119414], [0.07513223]]]],
dtype=np.float32)
parameter_data = ng.parameter(data_shape, name='Data', dtype=np.float32)
model = ng.mvn(parameter_data, axis, normalize_variance, eps)
computation = runtime.computation(model, parameter_data)
result = computation(data_value)
data_mean = np.mean(data_value, axis=(0, 2, 3), keepdims=1)
data_mean_squared = np.power(data_mean, 2)
data_squared = np.power(data_value, 2)
data_squared_mean = np.mean(data_squared, axis=(0, 2, 3), keepdims=1)
std = np.sqrt(data_squared_mean - data_mean_squared)
expected = (data_value - data_mean) / (std + 1e-9)
assert np.allclose(result, expected)
def test_depth_to_space():
runtime = get_runtime()
data_value = np.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]],
]],
dtype=np.float32,
)
mode = "blocks_first"
block_size = np.float32(2)
data_shape = [1, 4, 2, 3]
parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32)
model = ng.depth_to_space(parameter_data, mode, block_size)
computation = runtime.computation(model, parameter_data)
result = computation(data_value)
expected = np.array(
[[[
[0, 6, 1, 7, 2, 8],
[12, 18, 13, 19, 14, 20],
[3, 9, 4, 10, 5, 11],
[15, 21, 16, 22, 17, 23],
]]],
dtype=np.float32,
)
assert np.allclose(result, expected)
def test_argmin():
runtime = get_runtime()
input_x = ng.constant(
np.array([[12, 2, 10], [9, 8, 4], [6, 1, 5], [3, 11, 7]],
dtype=np.float32))
model = runtime.computation(ng.argmin(input_x, 0))
result = model()
assert np.allclose(result, np.array([3, 2, 1], dtype=np.int32))
def test_rnn_cell_operator():
runtime = get_runtime()
batch_size = 2
input_size = 3
hidden_size = 3
X_shape = [batch_size, input_size]
W_shape = [hidden_size, input_size]
R_shape = [hidden_size, hidden_size]
H_t_shape = [batch_size, hidden_size]
B_shape = [2 * hidden_size]
parameter_X = ng.parameter(X_shape, name='X', dtype=np.float32)
parameter_W = ng.parameter(W_shape, name='W', dtype=np.float32)
parameter_R = ng.parameter(R_shape, name='R', dtype=np.float32)
parameter_H_t = ng.parameter(H_t_shape, name='H_t', dtype=np.float32)
parameter_B = ng.parameter(B_shape, name='B', dtype=np.float32)
X_value = np.array(
[0.3432185, 0.612268, 0.20272376, 0.9513413, 0.30585995, 0.7265472],
dtype=np.float32).reshape(X_shape)
W_value = np.array([
0.41930267, 0.7872176, 0.89940447, 0.23659843, 0.24676207, 0.17101714,
0.3147149, 0.6555601, 0.4559603
],
dtype=np.float32).reshape(W_shape)
R_value = np.array([
0.8374871, 0.86660194, 0.82114047, 0.71549815, 0.18775631, 0.3182116,
0.25392973, 0.38301638, 0.85531586
],
dtype=np.float32).reshape(R_shape)
H_t_value = np.array(
[0.12444675, 0.52055854, 0.46489045, 0.4983964, 0.7730452, 0.28439692],
dtype=np.float32).reshape(H_t_shape)
B_value = np.array([
0.45513555, 0.96227735, 0.24737759, 0.57380486, 0.67398053, 0.18968852
],
dtype=np.float32).reshape(B_shape)
activations = ['sigmoid']
activation_alpha = []
activation_beta = []
clip = 2.88
model = ng.rnn_cell(parameter_X, parameter_W, parameter_R, parameter_H_t,
hidden_size, parameter_B, activations,
activation_alpha, activation_beta, clip)
computation = runtime.computation(model, parameter_X, parameter_W,
parameter_R, parameter_H_t, parameter_B)
result = computation(X_value, W_value, R_value, H_t_value, B_value)
expected = np.array(
[0.94126844, 0.9036043, 0.841243, 0.9468489, 0.934215, 0.873708],
dtype=np.float32).reshape(batch_size, hidden_size)
assert np.allclose(result, expected)
def test_onehot():
runtime = get_runtime()
param = ng.parameter([3], dtype=np.int32)
model = ng.one_hot(param, 3, 1, 0, 0)
computation = runtime.computation(model, param)
expected = np.eye(3)[np.array([1, 0, 2])]
input_data = np.array([1, 0, 2], dtype=np.int32)
result = computation(input_data)
assert np.allclose(result, expected)
def test_mvn_operator():
runtime = get_runtime()
data_shape = [3, 3, 3, 1]
across_channels = True
normalize_variance = True
eps = np.float32(1e-9)
data_value = np.array(
[
[
[[0.8439683], [0.5665144], [0.05836735]],
[[0.02916367], [0.12964272], [0.5060197]],
[[0.79538304], [0.9411346], [0.9546573]],
],
[
[[0.17730942], [0.46192095], [0.26480448]],
[[0.6746842], [0.01665257], [0.62473077]],
[[0.9240844], [0.9722341], [0.11965699]],
],
[
[[0.41356155], [0.9129373], [0.59330076]],
[[0.81929934], [0.7862604], [0.11799799]],
[[0.69248444], [0.54119414], [0.07513223]],
],
],
dtype=np.float32,
)
parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32)
model = ng.mvn(parameter_data, across_channels, normalize_variance, eps)
computation = runtime.computation(model, parameter_data)
result = computation(data_value)
expected = np.array([
[
[[0.9951074], [0.14548765], [-1.410561]],
[[-1.4999886], [-1.1923014], [-0.03975919]],
[[0.8463296], [1.2926502], [1.3340596]],
],
[
[[-1.0463363], [-0.1747985], [-0.7784088]],
[[0.47672555], [-1.5383], [0.32375798]],
[[1.2404392], [1.3878832], [-1.2228798]],
],
[
[[-0.3228847], [1.2063044], [0.22751297]],
[[0.91956615], [0.81839436], [-1.2279599]],
[[0.5312334], [0.067952], [-1.3592235]],
],
], )
assert np.allclose(result, expected)
def test_split():
runtime = get_runtime()
input_tensor = ng.constant(np.array([0, 1, 2, 3, 4, 5], dtype=np.int32))
axis = ng.constant(0, dtype=np.int64)
splits = 3
split_node = ng.split(input_tensor, axis, splits)
computation = runtime.computation(split_node)
split_results = computation()
expected_results = np.array([[0, 1], [2, 3], [4, 5]], dtype=np.int32)
assert np.allclose(split_results, expected_results)
def test_elu_operator_with_scalar_and_array():
runtime = get_runtime()
data_value = np.array([[-5, 1], [-2, 3]], dtype=np.float32)
alpha_value = np.float32(3)
model = ng.elu(data_value, alpha_value)
computation = runtime.computation(model)
result = computation()
expected = np.array([[-2.9797862, 1.], [-2.5939941, 3.]], dtype=np.float32)
assert np.allclose(result, expected)
def test_avg_pool_2d(_ndarray_1x1x4x4):
runtime = get_runtime()
input_data = _ndarray_1x1x4x4
param = ng.parameter(input_data.shape, name='A', dtype=np.float32)
kernel_shape = [2, 2]
spatial_dim_count = len(kernel_shape)
pads_begin = [0] * spatial_dim_count
pads_end = [0] * spatial_dim_count
strides = [2, 2]
exclude_pad = True
expected = [[[[13.5, 15.5],
[21.5, 23.5]]]]
avg_pool_node = ng.avg_pool(param, strides, pads_begin, pads_end,
kernel_shape, exclude_pad)
computation = runtime.computation(avg_pool_node, param)
result = computation(input_data)
assert np.allclose(result, expected)
expected = [[[[13.5, 14.5, 15.5],
[17.5, 18.5, 19.5],
[21.5, 22.5, 23.5]]]]
strides = [1, 1]
avg_pool_node = ng.avg_pool(param, strides, pads_begin, pads_end,
kernel_shape, exclude_pad)
computation = runtime.computation(avg_pool_node, param)
result = computation(input_data)
assert np.allclose(result, expected)
pads_begin = [1, 1]
pads_end = [1, 1]
strides = [2, 2]
exclude_pad = True
expected = [[[[11.0, 12.5, 14.0],
[17.0, 18.5, 20.0],
[23.0, 24.5, 26.0]]]]
avg_pool_node = ng.avg_pool(param, strides, pads_begin, pads_end,
kernel_shape, exclude_pad)
computation = runtime.computation(avg_pool_node, param)
result = computation(input_data)
assert np.allclose(result, expected)
exclude_pad = False
expected = [[[[2.75, 6.25, 3.5],
[8.5, 18.5, 10.0],
[5.75, 12.25, 6.5]]]]
avg_pool_node = ng.avg_pool(param, strides, pads_begin, pads_end,
kernel_shape, exclude_pad)
computation = runtime.computation(avg_pool_node, param)
result = computation(input_data)
assert np.allclose(result, expected)
def test_space_to_depth_operator():
runtime = get_runtime()
data_shape = [1, 2, 4, 4]
data_value = np.arange(start=0, stop=32, step=1.0,
dtype=np.float32).reshape(data_shape)
mode = "blocks_first"
block_size = 2
parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32)
model = ng.space_to_depth(parameter_data, mode, block_size)
computation = runtime.computation(model, parameter_data)
result = computation(data_value)
expected = np.array(
[
0,
2,
8,
10,
16,
18,
24,
26,
1,
3,
9,
11,
17,
19,
25,
27,
4,
6,
12,
14,
20,
22,
28,
30,
5,
7,
13,
15,
21,
23,
29,
31,
],
dtype=np.float32,
).reshape(1, 8, 2, 2)
assert np.allclose(result, expected)
def test_convolution_backprop_data():
runtime = get_runtime()
output_spatial_shape = [9, 9]
filter_shape = [1, 1, 3, 3]
data_shape = [1, 1, 7, 7]
strides = [1, 1]
data_node = ng.parameter(shape=data_shape)
filter_node = ng.parameter(shape=filter_shape)
output_shape_node = ng.constant(
np.array(output_spatial_shape, dtype=np.int64))
deconvolution = ng.convolution_backprop_data(data_node, filter_node,
strides, output_shape_node)
input_data = np.array(
[[[
[-20, -20, 20, 20, 0, 0, 0],
[-20, -20, 20, 20, 0, 0, 0],
[-20, -20, 20, 20, 0, 0, 0],
[-20, -20, 20, 20, 0, 0, 0],
[-20, -20, 20, 20, 0, 0, 0],
[-20, -20, 20, 20, 0, 0, 0],
[-20, -20, 20, 20, 0, 0, 0],
]]],
dtype=np.float32,
)
filter_data = np.array(
[[1.0, 0.0, -1.0], [2.0, 0.0, -2.0], [1.0, 0.0, -1.0]],
dtype=np.float32).reshape(1, 1, 3, 3)
model = runtime.computation(deconvolution, data_node, filter_node)
result = model(input_data, filter_data)
assert np.allclose(
result,
np.array(
[[[
[-20.0, -20.0, 40.0, 40.0, -20.0, -20.0, 0.0, 0.0, 0.0],
[-60.0, -60.0, 120.0, 120.0, -60.0, -60.0, 0.0, 0.0, 0.0],
[-80.0, -80.0, 160.0, 160.0, -80.0, -80.0, 0.0, 0.0, 0.0],
[-80.0, -80.0, 160.0, 160.0, -80.0, -80.0, 0.0, 0.0, 0.0],
[-80.0, -80.0, 160.0, 160.0, -80.0, -80.0, 0.0, 0.0, 0.0],
[-80.0, -80.0, 160.0, 160.0, -80.0, -80.0, 0.0, 0.0, 0.0],
[-80.0, -80.0, 160.0, 160.0, -80.0, -80.0, 0.0, 0.0, 0.0],
[-60.0, -60.0, 120.0, 120.0, -60.0, -60.0, 0.0, 0.0, 0.0],
[-20.0, -20.0, 40.0, 40.0, -20.0, -20.0, 0.0, 0.0, 0.0],
]]],
dtype=np.float32,
),
)
def test_concat():
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])
axis = 0
expected = np.concatenate((a, b), axis=0)
runtime = get_runtime()
parameter_a = ng.parameter(list(a.shape), name='A', dtype=np.float32)
parameter_b = ng.parameter(list(b.shape), name='B', dtype=np.float32)
node = ng.concat([parameter_a, parameter_b], axis)
computation = runtime.computation(node, parameter_a, parameter_b)
result = computation(a, b)
assert np.allclose(result, expected)
def test_gelu_operator_with_array():
runtime = get_runtime()
data_value = np.array([[-5, 1], [-2, 3]], dtype=np.float32)
model = ng.gelu(data_value)
computation = runtime.computation(model)
result = computation()
expected = np.array([[-1.4901161e-06, 8.4134471e-01], [-4.5500278e-02, 2.9959502]],
dtype=np.float32)
assert np.allclose(result, expected, .007, .007)
def test_cum_sum(input_shape, cumsum_axis, reverse):
input_data = np.arange(np.prod(input_shape)).reshape(input_shape)
if reverse:
expected = np.cumsum(input_data[::-1], axis=cumsum_axis)[::-1]
else:
expected = np.cumsum(input_data, axis=cumsum_axis)
runtime = get_runtime()
node = ng.cum_sum(input_data, cumsum_axis, reverse=reverse)
computation = runtime.computation(node)
result = computation()
assert np.allclose(result, expected)
def test_concat():
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])
axis = 0
expected = np.concatenate((a, b), axis=0)
runtime = get_runtime()
parameter_a = ng.parameter(list(a.shape), name='A', dtype=np.float32)
parameter_b = ng.parameter(list(b.shape), name='B', dtype=np.float32)
node = ng.concat([parameter_a, parameter_b], axis)
computation = runtime.computation(node, parameter_a, parameter_b)
result = computation(a, b)
assert np.allclose(result, expected)
def test_unsqueeze():
runtime = get_runtime()
data_shape = [3, 4, 5]
parameter_data = ng.parameter(data_shape, name='Data', dtype=np.float32)
data_value = np.arange(60., dtype=np.float32).reshape(3, 4, 5)
axes = [0, 4]
model = ng.unsqueeze(parameter_data, axes)
computation = runtime.computation(model, parameter_data)
result = computation(data_value)
expected = np.arange(60., dtype=np.float32).reshape(1, 3, 4, 5, 1)
assert np.allclose(result, expected)
def test_squeeze_operator():
runtime = get_runtime()
data_shape = [1, 2, 1, 3, 1, 1]
parameter_data = ng.parameter(data_shape, name='Data', dtype=np.float32)
data_value = np.arange(6., dtype=np.float32).reshape(1, 2, 1, 3, 1, 1)
axes = [2, 4]
model = ng.squeeze(parameter_data, axes)
computation = runtime.computation(model, parameter_data)
result = computation(data_value)
expected = np.arange(6., dtype=np.float32).reshape(1, 2, 3, 1)
assert np.allclose(result, expected)
def test_import_onnx_function():
model_path = os.path.join(os.path.dirname(__file__), 'models/add_abc.onnx')
ng_function = import_onnx_model_file(model_path)
dtype = np.float32
value_a = np.array([1.0], dtype=dtype)
value_b = np.array([2.0], dtype=dtype)
value_c = np.array([3.0], dtype=dtype)
runtime = get_runtime()
computation = runtime.computation(ng_function)
result = computation(value_a, value_b, value_c)
assert np.allclose(result, np.array([6], dtype=dtype))
def test_avg_pooling_3d(_ndarray_1x1x4x4):
rt = get_runtime()
data = _ndarray_1x1x4x4
data = np.broadcast_to(data, (1, 1, 4, 4, 4))
param = ng.parameter(list(data.shape))
window_shape = [2, 2, 2]
strides = [2, 2, 2]
avgpool = ng.avg_pool(param, window_shape, strides)
comp = rt.computation(avgpool, param)
result = comp(data)
result_ref = [[[[[13.5, 15.5], [21.5, 23.5]], [[13.5, 15.5], [21.5,
23.5]]]]]
assert np.allclose(result, result_ref)
def test_clamp_operator_with_array():
runtime = get_runtime()
data_value = np.array([[-5, 9], [45, 3]], dtype=np.float32)
min_value = np.float32(3)
max_value = np.float32(12)
model = ng.clamp(data_value, min_value, max_value)
computation = runtime.computation(model)
result = computation()
expected = np.clip(data_value, min_value, max_value)
assert np.allclose(result, expected)
def test_group_convolution_backprop_data():
runtime = get_runtime()
data_shape = [1, 1, 3, 3]
filters_shape = [1, 1, 1, 3, 3]
strides = [2, 2]
output_padding = [1, 1]
pads_begin = [1, 1]
pads_end = [1, 1]
data_node = ng.parameter(data_shape, name='Data', dtype=np.float32)
filters_node = ng.parameter(filters_shape,
name='Filters',
dtype=np.float32)
model = ng.group_convolution_backprop_data(data_node,
filters_node,
strides,
None,
pads_begin,
pads_end,
output_padding=output_padding)
data_value = np.array([
0.16857791, -0.15161794, 0.08540368, 0.1820628, -0.21746576,
0.08245695, 0.1431433, -0.43156421, 0.30591947
],
dtype=np.float32).reshape(data_shape)
filters_value = np.array([
-0.06230065, 0.37932432, -0.25388849, 0.33878803, 0.43709868,
-0.22477469, 0.04118127, -0.44696793, 0.06373066
],
dtype=np.float32).reshape(filters_shape)
computation = runtime.computation(model, data_node, filters_node)
result = computation(data_value, filters_value)
expected = np.array([
0.07368518, -0.08925839, -0.06627201, 0.06301362, 0.03732984,
-0.01919658, -0.00628807, -0.02817563, -0.01472169, 0.04392925,
-0.00689478, -0.01549204, 0.07957941, -0.11459791, -0.09505399,
0.07681622, 0.03604182, -0.01853423, -0.0270785, -0.00680824,
-0.06650258, 0.08004665, 0.07918708, 0.0724144, 0.06256775,
-0.17838378, -0.18863615, 0.20064656, 0.133717, -0.06876295,
-0.06398046, -0.00864975, 0.19289537, -0.01490572, -0.13673618,
0.01949645
],
dtype=np.float32).reshape(1, 1, 6, 6)
assert np.allclose(result, expected)
def test_avg_pool_2d(_ndarray_1x1x4x4):
runtime = get_runtime()
input_data = _ndarray_1x1x4x4
param = ng.parameter(input_data.shape, name='A', dtype=np.float32)
window_shape = [2, 2]
strides = [2, 2]
expected = [[[[13.5, 15.5],
[21.5, 23.5]]]]
avg_pool_node = ng.avg_pool(param, window_shape, strides)
computation = runtime.computation(avg_pool_node, param)
result = computation(input_data)
assert np.allclose(result, expected)
expected = [[[[13.5, 14.5, 15.5],
[17.5, 18.5, 19.5],
[21.5, 22.5, 23.5]]]]
avg_pool_node = ng.avg_pool(param, window_shape)
computation = runtime.computation(avg_pool_node, param)
result = computation(input_data)
assert np.allclose(result, expected)
padding_below = [1, 1]
padding_above = [1, 1]
strides = [2, 2]
include_pad = False
expected = [[[[11.0, 12.5, 14.0],
[17.0, 18.5, 20.0],
[23.0, 24.5, 26.0]]]]
avg_pool_node = ng.avg_pool(param, window_shape, strides, padding_below, padding_above,
include_pad)
computation = runtime.computation(avg_pool_node, param)
result = computation(input_data)
assert np.allclose(result, expected)
include_pad = True
expected = [[[[2.75, 6.25, 3.5],
[8.5, 18.5, 10.0],
[5.75, 12.25, 6.5]]]]
avg_pool_node = ng.avg_pool(param, window_shape, strides, padding_below, padding_above,
include_pad)
computation = runtime.computation(avg_pool_node, param)
result = computation(input_data)
assert np.allclose(result, expected)
def test_avg_pooling_3d(_ndarray_1x1x4x4):
rt = get_runtime()
data = _ndarray_1x1x4x4
data = np.broadcast_to(data, (1, 1, 4, 4, 4))
param = ng.parameter(list(data.shape))
window_shape = [2, 2, 2]
strides = [2, 2, 2]
avgpool = ng.avg_pool(param, window_shape, strides)
comp = rt.computation(avgpool, param)
result = comp(data)
result_ref = [[[[[13.5, 15.5],
[21.5, 23.5]],
[[13.5, 15.5],
[21.5, 23.5]]]]]
assert np.allclose(result, result_ref)
def test_function_call():
runtime = get_runtime()
dtype = int
shape = [2, 2]
parameter_a = ng.parameter(shape, dtype=dtype, name='A')
parameter_b = ng.parameter(shape, dtype=dtype, name='B')
parameter_c = ng.parameter(shape, dtype=dtype, name='C')
parameter_list = [parameter_a, parameter_b, parameter_c]
ops = ((parameter_a + parameter_b) * parameter_c)
func = Function(NodeVector([ops]), parameter_list, 'addmul')
fc = ng.function_call(func, NodeVector(parameter_list))
computation = runtime.computation(fc, parameter_a, parameter_b, parameter_c)
value_a = np.array([[1, 2], [3, 4]], dtype=dtype)
value_b = np.array([[5, 6], [7, 8]], dtype=dtype)
value_c = np.array([[9, 10], [11, 12]], dtype=dtype)
result = computation(value_a, value_b, value_c)
assert np.allclose(result, np.array([[54, 80], [110, 144]], dtype=dtype))
def test_simple_computation_on_ndarrays(dtype):
runtime = get_runtime()
shape = [2, 2]
parameter_a = ng.parameter(shape, dtype=dtype, name='A')
parameter_b = ng.parameter(shape, dtype=dtype, name='B')
parameter_c = ng.parameter(shape, dtype=dtype, name='C')
model = (parameter_a + parameter_b) * parameter_c
computation = runtime.computation(model, parameter_a, parameter_b, parameter_c)
value_a = np.array([[1, 2], [3, 4]], dtype=dtype)
value_b = np.array([[5, 6], [7, 8]], dtype=dtype)
value_c = np.array([[9, 10], [11, 12]], dtype=dtype)
result = computation(value_a, value_b, value_c)
assert np.allclose(result, np.array([[54, 80], [110, 144]], dtype=dtype))
value_a = np.array([[13, 14], [15, 16]], dtype=dtype)
value_b = np.array([[17, 18], [19, 20]], dtype=dtype)
value_c = np.array([[21, 22], [23, 24]], dtype=dtype)
result = computation(value_a, value_b, value_c)
assert np.allclose(result, np.array([[630, 704], [782, 864]], dtype=dtype))
