def test_fused_batch_norm(self, use_cpu_only, func, backend, epsilon): input_shape = np.random.randint(low=1, high=4, size=4) attr_shape = [list(input_shape)[-1]] m = random_gen(shape=attr_shape, rand_min=-1.0, rand_max=1.0) v = random_gen(shape=attr_shape, rand_min=0.0, rand_max=10.0) o = random_gen(shape=attr_shape, rand_min=1.0, rand_max=10.0) s = random_gen(shape=attr_shape, rand_min=-1.0, rand_max=1.0) @make_tf_graph([input_shape]) def build_model(x): return func( x=x, scale=s, offset=o, mean=m, variance=v, epsilon=epsilon, is_training=False, )[0] model, inputs, outputs = build_model input_values = [random_gen(shape=input_shape)] input_dict = dict(zip(inputs, input_values)) TensorFlowBaseTest.run_compare_tf( model, input_dict, outputs, use_cpu_for_conversion=use_cpu_only, backend=backend, atol=1e-2, rtol=1e-3, )
def test_builder_eval_stress(self, rank_and_axes, epsilon): rank, axes = rank_and_axes shape = np.random.randint(low=2, high=6, size=rank) x_val = random_gen(shape=shape, rand_min=-100.0, rand_max=100.0) positive_axes = [axis + rank if axis < 0 else axis for axis in axes] normalized_shape = [ shape[i] for i in range(rank) if i in positive_axes ] gamma_val = random_gen(shape=normalized_shape, rand_min=-100, rand_max=100) beta_val = random_gen(shape=normalized_shape, rand_min=-100, rand_max=100) with Function({}): res = mb.layer_norm(x=x_val, axes=axes, epsilon=epsilon, gamma=gamma_val, beta=beta_val) ref = TestNormalizationLayerNorm._np_layer_norm(x=x_val, axes=axes, epsilon=epsilon, gamma=gamma_val, beta=beta_val) np.testing.assert_allclose(ref, res.val, atol=1e-04, rtol=1e-05)
def test_resample( self, use_cpu_only, backend, data_warp_shapes, ): if backend[0] == "neuralnetwork": pytest.xfail("nn backend not supported") tfa = pytest.importorskip("tensorflow_addons") data_shape, warp_shape = data_warp_shapes @make_tf_graph([data_shape, warp_shape]) def build_model(x, warp): return tfa.image.resampler(data=x, warp=warp) model, inputs, outputs = build_model # warp exceeding input sizes in order to test more padding modes input_values = [ random_gen(data_shape, -100, 100), random_gen(warp_shape, -15, 15), ] input_dict = dict(zip(inputs, input_values)) self.run_compare_tf2( model, input_dict, outputs, use_cpu_only=use_cpu_only, backend=backend, )
def test_builder_to_backend_stress_numpy(self, use_cpu_only, backend, rank_and_axes, epsilon, provides_gamma_beta): if backend == ("mlprogram", "fp16") and not use_cpu_only: pytest.xfail( "rdar://80662357 ([GPU failures] LayerNorm FP16 tests failing on GPU with numerical errors)" ) rank, axes = rank_and_axes shape = np.random.randint(low=2, high=6, size=rank) x_val = random_gen(shape=shape, rand_min=-100.0, rand_max=100.0) input_placeholders = {"x": mb.placeholder(shape=x_val.shape)} input_values = {"x": x_val} gamma, beta = None, None if provides_gamma_beta: positive_axes = [ axis + rank if axis < 0 else axis for axis in axes ] normalized_shape = [ shape[i] for i in range(rank) if i in positive_axes ] gamma = random_gen(shape=normalized_shape, rand_min=-100, rand_max=100) beta = random_gen(shape=normalized_shape, rand_min=-100, rand_max=100) def build(x): return [ mb.layer_norm(x=x, axes=axes, epsilon=epsilon, gamma=gamma, beta=beta) ] output = TestNormalizationLayerNorm._np_layer_norm(x=x_val, axes=axes, epsilon=epsilon, gamma=gamma, beta=beta) expected_output_types = [tuple(output.shape) + (types.fp32, )] expected_outputs = [output] run_compare_builder( build, input_placeholders, input_values, expected_output_types, expected_outputs, use_cpu_only=use_cpu_only, backend=backend, atol=1e-3, rtol=1e-4, )
def test_builder_eval(self): x_val = random_gen(shape=(2, 2, 4), rand_min=-37, rand_max=64) y_val = random_gen(shape=(2, 4, 2), rand_min=-91, rand_max=84) v = mb.matmul(x=x_val, y=y_val) np.testing.assert_allclose(np.matmul(x_val, y_val), v.val, atol=1e-04, rtol=1e-05)
def test_builder_eval(self): cond = np.random.randint(low=0, high=2, size=(6, 1, 7)).astype(np.bool) a = random_gen(shape=(6, 1, 7), rand_min=-1962.0, rand_max=0.0) b = random_gen(shape=(6, 1, 7), rand_min=0.0, rand_max=1964.0) res = mb.select(cond=cond, a=a, b=b) np.testing.assert_allclose(np.where(cond, a, b), res.val, atol=1e-04, rtol=1e-05)
def test_tf( self, use_cpu_only, backend, transpose_a, transpose_b, a_is_sparse, b_is_sparse, b_is_const, ): if backend[0] == 'mlprogram': pytest.skip("Custom layer not supported with ML Program backend") rank = 2 shape = list(np.random.randint(low=3, high=100, size=1)) * rank with tf.Graph().as_default() as graph: x = tf.placeholder(tf.float32, shape=shape) if b_is_const: y_value = random_gen(shape, rand_min=-100, rand_max=100) y = tf.constant(y_value, dtype=tf.float32) else: y = tf.placeholder(tf.float32, shape=shape) ref = tf.sparse_matmul( x, y, transpose_a=transpose_a, transpose_b=transpose_b, a_is_sparse=a_is_sparse, b_is_sparse=b_is_sparse, ) mlmodel, _, _, _ = tf_graph_to_mlmodel( graph, { x: random_gen(shape, rand_min=-100, rand_max=100), } if b_is_const else { x: random_gen(shape, rand_min=-100, rand_max=100), y: random_gen(shape, rand_min=-100, rand_max=100), }, ref, backend=backend, ) layers = mlmodel.get_spec().neuralNetwork.layers assert layers[-1].custom is not None, "Expecting a custom layer" assert ("SparseMatMul" == layers[-1].custom.className ), "Custom Layer class name mis-match" assert (transpose_a == layers[-1].custom.parameters["transpose_x"]. boolValue), "Incorrect parameter value k" assert (transpose_b == layers[-1].custom.parameters["transpose_y"]. boolValue), "Incorrect parameter value k" assert (a_is_sparse == layers[-1].custom.parameters["x_is_sparse"]. boolValue), "Incorrect parameter value k" assert (b_is_sparse == layers[-1].custom.parameters["y_is_sparse"]. boolValue), "Incorrect parameter value k" assert len(layers) == 2 if b_is_const else len(layers) == 1
def test_builder_eval(self): x_val = random_gen(shape=(2, 2), rand_min=-37, rand_max=64) weight_val = random_gen(shape=(2, 2), rand_min=-91, rand_max=84) bias_val = random_gen(shape=(2, ), rand_min=0.0, rand_max=9.0) v = mb.linear(x=x_val, weight=weight_val, bias=bias_val) np.testing.assert_allclose(np.matmul(x_val, weight_val.T) + bias_val, v.val, atol=1e-04, rtol=1e-05)
def test_tf_image_resize(self, use_cpu_only, backend, size, method): if backend[0] == "mlprogram" and not use_cpu_only: pytest.xfail( "rdar://78343225 ((MIL GPU) Core ML Tools Unit Test failures [numerical error])" ) if backend[0] == "mlprogram" and size == (1, 1): pytest.xfail( "rdar://79699954 (Nearest neighbor resize numerical mismatch when output size is (1,1))" ) if backend[0] == "neuralnetwork": pytest.xfail("nn backend not supported") x_shape = tuple(np.random.randint(low=1, high=3, size=4)) @make_tf_graph([x_shape]) def build_model(x): return tf.image.resize(x, size=size, method=method) model, inputs, outputs = build_model input_values = [ random_gen(x_shape, -100, 100), ] input_dict = dict(zip(inputs, input_values)) self.run_compare_tf2( model, input_dict, outputs, use_cpu_only=use_cpu_only, backend=backend, )
def test(self, use_cpu_only, backend, transforms, interpolation, shapes): x_shape, output_shape = shapes if backend[0] == "neuralnetwork": pytest.xfail("nn backend not supported") tfa = pytest.importorskip("tensorflow_addons") @make_tf_graph([x_shape]) def build_model(x): return tfa.image.transform( x, transforms=transforms, interpolation=interpolation, output_shape=output_shape, ) model, inputs, outputs = build_model input_values = [ random_gen(x_shape, -100, 100), ] input_dict = dict(zip(inputs, input_values)) self.run_compare_tf2( model, input_dict, outputs, use_cpu_only=use_cpu_only, backend=backend, )
def test_builder_eval_stress(self, rank, epsilon): shape = np.random.randint(low=2, high=6, size=rank) x_val = random_gen(shape=shape, rand_min=-1, rand_max=1) with Function({}): res = mb.l2_norm(x=x_val, epsilon=epsilon) ref = TestNormalizationL2Norm._compute_l2_norm(x_val, epsilon) np.testing.assert_allclose(ref, res.val, atol=1e-6, rtol=1e-5)
def test_tf(self, use_cpu_only, backend, rank, k): if backend[0] == 'mlprogram': pytest.xfail("Custom layer not supported with ML Program backend") shape = np.random.randint(low=3, high=6, size=rank) with tf.Graph().as_default() as graph: x = tf.placeholder(tf.float32, shape=shape) ref = tf.math.top_k(x, k=k, sorted=True) ref = (ref[1], ref[0]) mlmodel, _, _, _ = tf_graph_to_mlmodel( graph, {x: random_gen(shape, rand_min=-100, rand_max=100)}, ref, backend=backend, ) layers = mlmodel.get_spec().neuralNetwork.layers assert layers[-1].custom is not None, "Expecting a custom layer" assert ( "TopK" == layers[-1].custom.className ), "Custom Layer class name mis-match" assert ( k == layers[-1].custom.parameters["k"].intValue ), "Incorrect parameter value k" assert ( layers[-1].custom.parameters["sorted"].boolValue is True ), "Incorrect parameter value for Sorted"
def test_builder_to_backend_stress(self, use_cpu_only, backend, rank): shape = np.random.randint(low=2, high=6, size=rank) x_val = random_gen(shape=shape, rand_min=-10.0, rand_max=10.0) input_placeholders = {"x": mb.placeholder(shape=shape)} input_values = {"x": x_val} def build(x): return [mb.l2_norm(x=x, epsilon=1e-12)] # compute for the answer batch_dims = rank - 3 if batch_dims == 0: norm = la.norm(x_val) output = x_val / norm else: batch_dim_prod = np.prod(shape[:batch_dims]) reshape_x_val = np.reshape(x_val, (batch_dim_prod, -1)) norm = la.norm(reshape_x_val, axis=1, keepdims=True) output = reshape_x_val / norm output = np.reshape(output, shape) expected_output_types = [list(output.shape) + [types.fp32]] expected_outputs = [output] run_compare_builder( build, input_placeholders, input_values, expected_output_types, expected_outputs, use_cpu_only=use_cpu_only, backend=backend, )
def test_builder_to_backend_stress(self, use_cpu_only, backend, input_shape, scale_factor, align_corners, recompute_scale_factor): scale_factor_height, scale_factor_width = scale_factor _, _, height, width = input_shape height = height * scale_factor_height width = width * scale_factor_width is_h_float = height - np.floor(height) > 0.001 is_w_float = width - np.floor(width) > 0.001 # Currently, MIL is not suporting recompute_scale_factor=False + align_corners=False # with fractional output size if not recompute_scale_factor and not align_corners and (is_h_float or is_w_float): pytest.xfail("rdar://81124053 (Support recompute_scale_factor)") def _get_torch_upsample_prediction(x, scale_factor=(2, 2), align_corners=False, recompute_scale_factor=True): x = torch.from_numpy(x) out = torch.nn.functional.interpolate( x, scale_factor=scale_factor, mode="bilinear", align_corners=align_corners, recompute_scale_factor=recompute_scale_factor, ) return out.numpy() x = random_gen(input_shape, rand_min=-100, rand_max=100) torch_pred = _get_torch_upsample_prediction( x, scale_factor=scale_factor, align_corners=align_corners, recompute_scale_factor=recompute_scale_factor, ) input_placeholder_dict = {"x": mb.placeholder(shape=x.shape)} input_value_dict = {"x": x} def build_upsample(x): return mb.upsample_bilinear( x=x, scale_factor_height=scale_factor[0], scale_factor_width=scale_factor[1], align_corners=align_corners, ) expected_output_type = torch_pred.shape + (types.fp32, ) run_compare_builder( build_upsample, input_placeholder_dict, input_value_dict, expected_output_type, torch_pred, use_cpu_only=use_cpu_only, frontend_only=False, backend=backend, )
def test_builder_to_backend_stress_keras(self, use_cpu_only, backend, rank_and_axes, epsilon): rank, axes = rank_and_axes shape = np.random.randint(low=2, high=6, size=rank) x_val = random_gen(shape=shape, rand_min=-100.0, rand_max=100.0) input_placeholders = {"x": mb.placeholder(shape=x_val.shape)} input_values = {"x": x_val} def build(x): return [ mb.layer_norm(x=x, axes=axes, epsilon=epsilon) ] output = TestNormalizationLayerNorm._keras_layer_norm(x=x_val, axes=axes, epsilon=epsilon) expected_output_types = [tuple(output.shape) + (types.fp32,)] expected_outputs = [ output ] run_compare_builder( build, input_placeholders, input_values, expected_output_types, expected_outputs, use_cpu_only=use_cpu_only, backend=backend, )
def test_builder_to_backend_stress( self, use_cpu_only, backend, rank, size, alpha, beta, k ): shape = np.random.randint(low=2, high=5, size=rank) x_val = random_gen(shape=shape) input_placeholders = {"x": mb.placeholder(shape=x_val.shape)} input_values = {"x": x_val} def build(x): return mb.local_response_norm(x=x, size=size, alpha=alpha, beta=beta, k=k) torch_lrn = torch.nn.LocalResponseNorm(size=size, alpha=alpha, beta=beta, k=k) expected_outputs = [torch_lrn(torch.as_tensor(x_val)).numpy()] expected_output_types = [o.shape[:] + (types.fp32,) for o in expected_outputs] run_compare_builder( build, input_placeholders, input_values, expected_output_types, expected_outputs, use_cpu_only=use_cpu_only, backend=backend, atol=1e-2, rtol=1e-3, )
def test_builder_to_backend_stress(self, rank, use_cpu_only, backend, epsilon): shape = np.random.randint(low=2, high=6, size=rank) x_val = random_gen(shape=shape, rand_min=-100.0, rand_max=100.0) input_placeholders = {"x": mb.placeholder(shape=x_val.shape)} input_values = {"x": x_val} def build(x): return mb.instance_norm(x=x, epsilon=epsilon) layer = torch.nn.InstanceNorm2d if rank == 4 else torch.nn.InstanceNorm1d torch_op = layer(num_features=shape[1], eps=epsilon) expected_outputs = [torch_op(torch.as_tensor(x_val)).numpy()] expected_output_types = [o.shape[:] + (types.fp32,) for o in expected_outputs] run_compare_builder( build, input_placeholders, input_values, expected_output_types, expected_outputs, use_cpu_only=use_cpu_only, backend=backend, atol=1e-3, rtol=1e-4, also_compare_shapes=True )
def test_reduce_log_sum(): x_val = random_gen(shape=(1, 3, 4, 4), rand_min=0.0, rand_max=100.0) res = mb.reduce_log_sum(x=x_val, axes=[axis], keep_dims=keep_dims).val ref = np.log(np.sum(x_val, axis=axis, keepdims=keep_dims)) np.testing.assert_allclose(ref, res, atol=1e-04, rtol=1e-05)
def test_infer_inputs_and_outputs(self): x_shape = (3, 4, 5) @make_tf_graph([x_shape]) def build_model(x): return tf.nn.relu(x) model, inputs, outputs = build_model mlmodel = converter.convert(model) assert mlmodel is not None input_values = [random_gen(x_shape, -10.0, 10.0)] input_dict = dict(zip(inputs, input_values)) run_compare_tf(model, input_dict, outputs)
def test_scalar_placeholder_shape(self): x_shape = () # Scalar Placeholder Shape @make_tf_graph([x_shape]) def build_model(x): return tf.nn.relu(x) model, inputs, outputs = build_model mlmodel = converter.convert(model, source=frontend) assert mlmodel is not None input_values = [random_gen(x_shape, -10.0, 10.0)] input_dict = dict(zip(inputs, input_values)) run_compare_tf(model, input_dict, outputs)
def test_infer_outputs(self): x_shape = (3, 4, 5) @make_tf_graph([x_shape]) def build_model(x): return tf.nn.relu(x) model, inputs, outputs = build_model input_name = ( inputs[0] if isinstance(inputs[0], six.string_types) else inputs[0].op.name ) mlmodel = converter.convert(model, inputs=[TensorType(input_name, (3, 4, 5))]) assert mlmodel is not None input_values = [random_gen(x_shape, -10.0, 10.0)] input_dict = dict(zip(inputs, input_values)) run_compare_tf(model, input_dict, outputs)
def test(self, use_cpu_only, backend, rank, tf_op): if backend[0] == "neuralnetwork": pytest.skip("nn backend not supported") x_shape = tuple(np.random.randint(low=1, high=4, size=rank)) @make_tf_graph([x_shape]) def build_model(x): return tf_op(x) model, inputs, outputs = build_model input_values = [ random_gen(x_shape, -100, 100), ] input_dict = dict(zip(inputs, input_values)) self.run_compare_tf2( model, input_dict, outputs, use_cpu_for_conversion=use_cpu_only, backend=backend, )
def test_keras_layer(self, use_cpu_only, backend, size): if backend[0] == "neuralnetwork": pytest.skip("nn backend not supported") x_shape = tuple(np.random.randint(low=1, high=4, size=4)) @make_tf_graph([x_shape]) def build_model(x): return tf.keras.layers.UpSampling2D( size=size, interpolation="nearest", )(x) model, inputs, outputs = build_model input_values = [random_gen(x_shape, -100, 100)] input_dict = dict(zip(inputs, input_values)) self.run_compare_tf2( model, input_dict, outputs, use_cpu_for_conversion=use_cpu_only, backend=backend, )
def test_raw_ops( self, use_cpu_only, backend, input_shape, target_shape, align_corners, half_pixel_centers, ): if align_corners is True and half_pixel_centers is True: return if backend[0] == "neuralnetwork": # neural network backend does not support fractional scale factors for nearest neighbor upsample op if target_shape[-1] % input_shape[-1] != 0: return if target_shape[-2] % input_shape[-2] != 0: return if not use_cpu_only and not half_pixel_centers and backend[ 0] == "mlprogram": # use_cpu_only == False & half_pixel_centers == False, & backend[0] == mlprogram # then there are numerical errors pytest.xfail("rdar://78321005") @make_tf_graph([input_shape]) def build_model(x): return tf.raw_ops.ResizeNearestNeighbor( images=x, size=target_shape, align_corners=align_corners, half_pixel_centers=half_pixel_centers, ) model, inputs, outputs = build_model input_values = [random_gen(input_shape, -100, 100)] input_dict = dict(zip(inputs, input_values)) self.run_compare_tf2( model, input_dict, outputs, use_cpu_only=use_cpu_only, backend=backend, )
def test_selu(self, use_cpu_only, backend, rank): input_shape = np.random.randint(low=1, high=6, size=rank) @make_tf_graph([input_shape]) def build_model(x): return tf.keras.activations.selu(x) model, inputs, outputs = build_model input_values = [random_gen(input_shape, -10.0, 10.0)] input_dict = dict(zip(inputs, input_values)) TensorFlowBaseTest.run_compare_tf( model, input_dict, outputs, use_cpu_only=use_cpu_only, frontend_only=False, backend=backend, )
def test_infer_inputs(self): x_shape = (3, 4, 5) @make_tf_graph([x_shape]) def build_model(x): return tf.nn.relu(x) model, inputs, outputs = build_model if not isinstance(outputs, (tuple, list)): outputs = [outputs] output_names = [ j if isinstance(j, six.string_types) else j.op.name for j in outputs ] mlmodel = converter.convert(model, outputs=output_names) assert mlmodel is not None input_values = [random_gen(x_shape, -10.0, 10.0)] input_dict = dict(zip(inputs, input_values)) run_compare_tf(model, input_dict, outputs)
def test_builder_to_backend_stress(self, use_cpu_only, backend, rank, epsilon): shape = np.random.randint(low=2, high=6, size=rank) x_val = random_gen(shape=shape, rand_min=-1.0, rand_max=1.0) input_placeholders = {"x": mb.placeholder(shape=shape)} input_values = {"x": x_val} def build(x): return [mb.l2_norm(x=x, epsilon=epsilon)] output = TestNormalizationL2Norm._compute_l2_norm(x_val, epsilon) expected_output_types = [list(output.shape) + [types.fp32]] expected_outputs = [ output ] run_compare_builder( build, input_placeholders, input_values, expected_output_types, expected_outputs, use_cpu_only=use_cpu_only, backend=backend, )
def test_shaping_utils(self): @make_tf_graph([(None, 4, 5)]) def build_flexible_model(x): return tf.nn.relu(x) model, inputs, outputs = build_flexible_model input_name = TFConverter._get_tensor_name(inputs[0]) output_name = TFConverter._get_tensor_name(outputs[0]) # static-Flexible shape mlmodel = converter.convert( model, inputs=[ # Use TF's input shapes (None, 4, 5) TensorType(name=input_name)], outputs=[output_name] ) assert mlmodel is not None input_values = [random_gen((3, 4, 5), -10.0, 10.0)] input_dict = {input_name: input_values[0]} if _IS_MACOS: ret = mlmodel.predict(input_dict) np.allclose(ret[output_name], np.maximum(input_values[0], 0.0)) # Enumerate shape inputs_shape = [ TensorType(input_name, EnumeratedShapes(shapes=[(3, 4, 5), (4, 4, 5)])) ] mlmodel = converter.convert(model, inputs=inputs_shape, outputs=[output_name]) assert mlmodel is not None input_values = [random_gen((3, 4, 5), -10.0, 10.0)] input_dict = {input_name: input_values[0]} if _IS_MACOS: ret = mlmodel.predict(input_dict) np.allclose(ret[output_name], np.maximum(input_values[0], 0.0)) input_values = [random_gen((4, 4, 5), -10.0, 10.0)] input_dict = {input_name: input_values[0]} if _IS_MACOS: ret = mlmodel.predict(input_dict) np.allclose(ret[output_name], np.maximum(input_values[0], 0.0)) if _IS_MACOS: with pytest.raises(RuntimeError) as e: input_values = [random_gen((5, 4, 5), -10.0, 10.0)] input_dict = {input_name: input_values[0]} ret = mlmodel.predict(input_dict) # Ranged shape inputs_shape = [TensorType(input_name, [RangeDim(3, 5), 4, 5])] mlmodel = converter.convert(model, inputs=inputs_shape, outputs=[output_name]) assert mlmodel is not None input_values = [random_gen((3, 4, 5), -10.0, 10.0)] input_dict = {input_name: input_values[0]} if _IS_MACOS: ret = mlmodel.predict(input_dict) np.allclose(ret[output_name], np.maximum(input_values[0], 0.0)) input_values = [random_gen((4, 4, 5), -10.0, 10.0)] input_dict = {input_name: input_values[0]} if _IS_MACOS: ret = mlmodel.predict(input_dict) np.allclose(ret[output_name], np.maximum(input_values[0], 0.0)) if _IS_MACOS: with pytest.raises(RuntimeError) as e: input_values = [random_gen((2, 4, 5), -10.0, 10.0)] input_dict = {input_name: input_values[0]} ret = mlmodel.predict(input_dict)
def test_builder_eval(self, axis, keep_dims): x_val = random_gen(shape=(1, 3, 4, 4), rand_min=-100.0, rand_max=100.0) @ssa_fn def test_reduce_argmax(): res = mb.reduce_argmax(x=x_val, axis=axis, keep_dims=keep_dims).val ref = np.argmax(x_val, axis=axis) if keep_dims: ref = np.expand_dims(ref, axis=axis) np.testing.assert_allclose(ref, res, atol=1e-04, rtol=1e-05) @ssa_fn def test_reduce_argmin(): res = mb.reduce_argmin(x=x_val, axis=axis, keep_dims=keep_dims).val ref = np.argmin(x_val, axis=axis) if keep_dims: ref = np.expand_dims(ref, axis=axis) np.testing.assert_allclose(ref, res, atol=1e-04, rtol=1e-05) @ssa_fn def test_reduce_l1_norm(): res = mb.reduce_l1_norm(x=x_val, axes=[axis], keep_dims=keep_dims).val ref = np.sum(np.abs(x_val), axis=axis, keepdims=keep_dims) np.testing.assert_allclose(ref, res, atol=1e-04, rtol=1e-05) @ssa_fn def test_reduce_l2_norm(): res = mb.reduce_l2_norm(x=x_val, axes=[axis], keep_dims=keep_dims).val ref = np.sqrt( np.sum(np.square(x_val), axis=axis, keepdims=keep_dims)) np.testing.assert_allclose(ref, res, atol=1e-04, rtol=1e-05) @ssa_fn def test_reduce_log_sum(): x_val = random_gen(shape=(1, 3, 4, 4), rand_min=0.0, rand_max=100.0) res = mb.reduce_log_sum(x=x_val, axes=[axis], keep_dims=keep_dims).val ref = np.log(np.sum(x_val, axis=axis, keepdims=keep_dims)) np.testing.assert_allclose(ref, res, atol=1e-04, rtol=1e-05) @ssa_fn def test_reduce_log_sum_exp(): res = mb.reduce_log_sum_exp(x=x_val, axes=[axis], keep_dims=keep_dims).val ref = scipy.special.logsumexp(x_val, axis=axis, keepdims=keep_dims) np.testing.assert_allclose(ref, res, atol=1e-04, rtol=1e-05) @ssa_fn def test_reduce_max(): res = mb.reduce_max(x=x_val, axes=[axis], keep_dims=keep_dims).val ref = np.max(x_val, axis=axis, keepdims=keep_dims) np.testing.assert_allclose(ref, res, atol=1e-04, rtol=1e-05) @ssa_fn def test_reduce_mean(): res = mb.reduce_mean(x=x_val, axes=[axis], keep_dims=keep_dims).val ref = np.mean(x_val, axis=axis, keepdims=keep_dims) np.testing.assert_allclose(ref, res, atol=1e-04, rtol=1e-05) @ssa_fn def test_reduce_min(): res = mb.reduce_min(x=x_val, axes=[axis], keep_dims=keep_dims).val ref = np.min(x_val, axis=axis, keepdims=keep_dims) np.testing.assert_allclose(ref, res, atol=1e-04, rtol=1e-05) @ssa_fn def test_reduce_prod(): res = mb.reduce_prod(x=x_val, axes=[axis], keep_dims=keep_dims).val ref = np.prod(x_val, axis=axis, keepdims=keep_dims) np.testing.assert_allclose(ref, res, atol=1e-04, rtol=1e-05) @ssa_fn def test_reduce_sum(): res = mb.reduce_sum(x=x_val, axes=[axis], keep_dims=keep_dims).val ref = np.sum(x_val, axis=axis, keepdims=keep_dims) np.testing.assert_allclose(ref, res, atol=1e-04, rtol=1e-05) @ssa_fn def test_reduce_sum_square(): res = mb.reduce_sum_square(x=x_val, axes=[axis], keep_dims=keep_dims).val ref = np.sum(np.square(x_val), axis=axis, keepdims=keep_dims) np.testing.assert_allclose(ref, res, atol=1e-04, rtol=1e-05) test_reduce_argmax() test_reduce_argmin() test_reduce_l1_norm() test_reduce_l2_norm() test_reduce_log_sum() test_reduce_log_sum_exp() test_reduce_max() test_reduce_mean() test_reduce_min() test_reduce_prod() test_reduce_sum() test_reduce_sum_square()