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