From aa932d341a7d7da0ce96e036913950429999ee13 Mon Sep 17 00:00:00 2001 From: Ruslan Nugmanov Date: Mon, 15 May 2023 13:03:09 +0200 Subject: [PATCH] Layer test tflite (#17410) * tfl argvalue test * tfl add_n test * tfl batch to space and space to batch * tfl batch to space and space to batch * tfl broadcast * tfl avgpool * tfl concat * tfl conv2d and depthtospace * tfl depthwise_conv2d * tfl broadcast_args * tfl fill * tfl floordiv * tfl fully_connected * tfl fully_connected * tfl gather * tfl gather_nd * tfl l2_normalization * tfl matrix_diag * tfl maxpool2d * tfl mirror_pad * tfl one_hot * tfl pack * tfl pad * tfl range * tfl relu * tfl reshape * tfl resize_bilinear * tfl resize * tfl reverse * tfl tfft2d * tfl scatter_nd * tfl rfft2d fix * tfl segment_sum * tfl select * tfl select_v2 * tfl slice * tfl space_to_depth * tfl split * tfl split_v * tfl strided_slice * tfl tile * tfl topk_v2 * tfl transpose * tfl transpose_conv * tfl fix conv tests * tfl unique + refactoring * tfl unpack * refactoring * tfl review - reformat params * tfl review - fixes * tfl review - fixes * tfl review - xfails * tfl review - remove redundant tickets * tfl review - xfail for pad --- .../common/tflite_layer_test_class.py | 7 +- .../layer_tests/common/utils/tflite_utils.py | 22 +++++- .../tensorflow_lite_tests/test_tfl_AddN.py | 46 ++++++++++++ .../test_tfl_ArgValue.py | 41 ++++++++++ .../test_tfl_BatchToSpaceND.py | 32 ++++++++ .../tensorflow_lite_tests/test_tfl_Binary.py | 23 ++---- .../test_tfl_BinaryWithActivation.py | 36 +++------ .../test_tfl_BroadcastArgs.py | 42 +++++++++++ .../test_tfl_BroadcastTo.py | 33 +++++++++ .../tensorflow_lite_tests/test_tfl_Concat.py | 39 ++++++++++ .../tensorflow_lite_tests/test_tfl_Conv2D.py | 43 +++++++++++ .../test_tfl_DepthToSpace.py | 31 ++++++++ .../test_tfl_DepthwiseConv2D.py | 39 ++++++++++ .../tensorflow_lite_tests/test_tfl_Fill.py | 32 ++++++++ .../test_tfl_FullyConnected.py | 35 +++++++++ .../tensorflow_lite_tests/test_tfl_Gather.py | 38 ++++++++++ .../test_tfl_GatherND.py | 50 +++++++++++++ .../test_tfl_L2Normalization.py | 37 ++++++++++ .../test_tfl_MatrixDiag.py | 34 +++++++++ .../test_tfl_MirrorPad.py | 39 ++++++++++ .../tensorflow_lite_tests/test_tfl_OneHot.py | 38 ++++++++++ .../tensorflow_lite_tests/test_tfl_Pack.py | 40 ++++++++++ .../tensorflow_lite_tests/test_tfl_Pad.py | 43 +++++++++++ .../tensorflow_lite_tests/test_tfl_Pool.py | 44 +++++++++++ .../tensorflow_lite_tests/test_tfl_RFFT2D.py | 34 +++++++++ .../tensorflow_lite_tests/test_tfl_Range.py | 52 +++++++++++++ .../tensorflow_lite_tests/test_tfl_Reduce.py | 27 ++----- .../tensorflow_lite_tests/test_tfl_Reshape.py | 34 +++++++++ .../tensorflow_lite_tests/test_tfl_Resize.py | 50 +++++++++++++ .../test_tfl_ReverseV2.py | 43 +++++++++++ .../test_tfl_ScatterND.py | 74 +++++++++++++++++++ .../test_tfl_SegmentSum.py | 44 +++++++++++ .../tensorflow_lite_tests/test_tfl_Select.py | 35 +++++++++ .../test_tfl_SelectV2.py | 36 +++++++++ .../tensorflow_lite_tests/test_tfl_Slice.py | 57 ++++++++++++++ .../test_tfl_SpaceToBatchND.py | 32 ++++++++ .../test_tfl_SpaceToDepth.py | 31 ++++++++ .../tensorflow_lite_tests/test_tfl_Split.py | 32 ++++++++ .../tensorflow_lite_tests/test_tfl_SplitV.py | 39 ++++++++++ .../test_tfl_StridedSlice.py | 69 +++++++++++++++++ .../tensorflow_lite_tests/test_tfl_Tile.py | 32 ++++++++ .../tensorflow_lite_tests/test_tfl_TopKV2.py | 33 +++++++++ .../test_tfl_Transpose.py | 32 ++++++++ .../test_tfl_TransposeConv.py | 45 +++++++++++ .../tensorflow_lite_tests/test_tfl_Unary.py | 20 ++--- .../tensorflow_lite_tests/test_tfl_Unique.py | 37 ++++++++++ .../tensorflow_lite_tests/test_tfl_Unpack.py | 41 ++++++++++ 47 files changed, 1712 insertions(+), 81 deletions(-) create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_AddN.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_ArgValue.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_BatchToSpaceND.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_BroadcastArgs.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_BroadcastTo.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_Concat.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_Conv2D.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_DepthToSpace.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_DepthwiseConv2D.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_Fill.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_FullyConnected.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_Gather.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_GatherND.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_L2Normalization.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_MatrixDiag.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_MirrorPad.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_OneHot.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_Pack.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_Pad.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_Pool.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_RFFT2D.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_Range.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_Reshape.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_Resize.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_ReverseV2.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_ScatterND.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_SegmentSum.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_Select.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_SelectV2.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_Slice.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_SpaceToBatchND.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_SpaceToDepth.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_Split.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_SplitV.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_StridedSlice.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_Tile.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_TopKV2.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_Transpose.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_TransposeConv.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_Unique.py create mode 100644 tests/layer_tests/tensorflow_lite_tests/test_tfl_Unpack.py diff --git a/tests/layer_tests/common/tflite_layer_test_class.py b/tests/layer_tests/common/tflite_layer_test_class.py index d1d89263b3a..b7d6a2043b9 100644 --- a/tests/layer_tests/common/tflite_layer_test_class.py +++ b/tests/layer_tests/common/tflite_layer_test_class.py @@ -5,7 +5,7 @@ os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' import tensorflow as tf from tensorflow.lite.tools import flatbuffer_utils as utils from common.layer_test_class import CommonLayerTest -from common.utils.tflite_utils import get_tflite_results, get_tensors_from_graph +from common.utils.tflite_utils import get_tflite_results, get_tensors_from_graph, data_generators class TFLiteLayerTest(CommonLayerTest): @@ -14,6 +14,11 @@ class TFLiteLayerTest(CommonLayerTest): outputs = None allowed_ops = None + def _prepare_input(self, inputs_dict, generator=None): + if generator is None: + return super()._prepare_input(inputs_dict) + return data_generators[generator](inputs_dict) + def make_model(self, params): raise RuntimeError("This is TensorFlow Lite base layer test class, " "please implement make_model function for the specific test") diff --git a/tests/layer_tests/common/utils/tflite_utils.py b/tests/layer_tests/common/utils/tflite_utils.py index 7edd77d667c..6e5f98c1475 100644 --- a/tests/layer_tests/common/utils/tflite_utils.py +++ b/tests/layer_tests/common/utils/tflite_utils.py @@ -1,7 +1,9 @@ +import itertools import os -import tensorflow as tf import numpy as np +import tensorflow as tf + from common.utils.tf_utils import summarize_graph, transpose_nhwc_to_nchw @@ -23,10 +25,17 @@ def make_boolean_array(inputs_dict): return inputs_dict +def make_int32_positive_array(inputs_dict): + for input in inputs_dict.keys(): + inputs_dict[input] = np.random.randint(1, 10, inputs_dict[input]).astype(np.int32) + return inputs_dict + + data_generators = { 'positive': make_positive_array, 'short_range': short_range, 'boolean': make_boolean_array, + 'int32_positive': make_int32_positive_array, } @@ -41,7 +50,7 @@ additional_test_params = [ [ {'axis': None}, {'axis': -1} - ], + ], [ {'activation': None}, {'activation': tf.nn.relu}, @@ -51,7 +60,7 @@ additional_test_params = [ # {'activation': tf.math.tanh}, # {'activation': lambda x, name: tf.identity(tf.experimental.numpy.signbit(x), name=name)}, {'activation': lambda x, name: tf.math.minimum(tf.math.maximum(-1., x), 1., name=name)} - ] + ] ] @@ -119,3 +128,10 @@ def get_tensors_from_graph(graph, ops: list): return tensors + +def parametrize_tests(lhs, rhs): + test_data = list(itertools.product(lhs, rhs)) + for i, (parameters, shapes) in enumerate(test_data): + parameters.update(shapes) + test_data[i] = parameters.copy() + return test_data diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_AddN.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_AddN.py new file mode 100644 index 00000000000..8e70824611a --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_AddN.py @@ -0,0 +1,46 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest +from common.utils.tflite_utils import parametrize_tests + +num_inputs = [ + {'num_inputs': 2}, + {'num_inputs': 4}, + {'num_inputs': 5}, +] + +test_params = [ + {'shape': [2, 10, 10, 3]}, + {'shape': [2, 10]} +] + +test_data = parametrize_tests(num_inputs, test_params) + + +class TestTFLiteAddNLayerTest(TFLiteLayerTest): + inputs = [] + outputs = ["AddN"] + allowed_ops = ['ADD_N'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'num_inputs'})) == 2, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + self.inputs = [] + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + inputs = [] + for j in range(params['num_inputs']): + name = f"Input_{j}" + self.inputs.append(name) + placeholder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], + name=name) + inputs.append(placeholder) + tf.math.add_n(inputs, name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_data) + @pytest.mark.nightly + def test_add_n(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_ArgValue.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_ArgValue.py new file mode 100644 index 00000000000..70dadf58722 --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_ArgValue.py @@ -0,0 +1,41 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest +from common.utils.tflite_utils import additional_test_params +from common.utils.tflite_utils import parametrize_tests + +test_ops = [ + {'op_name': 'ARG_MAX', 'op_func': tf.math.argmax}, + {'op_name': 'ARG_MIN', 'op_func': tf.math.argmin}, +] + +test_params = [ + {'shape': [2, 10, 10, 3]}, + {'shape': [2, 10]} +] + +test_data = parametrize_tests(test_ops, test_params) +test_data = parametrize_tests(test_data, additional_test_params[0]) + + +class TestTFLiteArgValueLayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["ArgValue"] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'op_name', 'op_func', 'shape', 'axis'})) == 4, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + self.allowed_ops = [params['op_name']] + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + place_holder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], + name=self.inputs[0]) + params['op_func'](place_holder, axis=params['axis'], name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_data) + @pytest.mark.nightly + def test_arg_value(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_BatchToSpaceND.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_BatchToSpaceND.py new file mode 100644 index 00000000000..1f04440c630 --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_BatchToSpaceND.py @@ -0,0 +1,32 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [8, 10, 10, 3], 'block_shape': [2, 2], 'crops': [[0, 2], [0, 0]]}, + {'shape': [24, 10, 10, 1], 'block_shape': [2, 12], 'crops': [[2, 0], [0, 2]]} +] + + +class TestTFLiteBatchToSpaceNDLayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["BatchToSpaceND"] + allowed_ops = ['BATCH_TO_SPACE_ND'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'block_shape', 'crops'})) == 3, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + place_holder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], + name=self.inputs[0]) + tf.batch_to_space(place_holder, params['block_shape'], params['crops'], + name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_batch_to_space_nd(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_Binary.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Binary.py index 22b9be44017..0aefc2733ae 100644 --- a/tests/layer_tests/tensorflow_lite_tests/test_tfl_Binary.py +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Binary.py @@ -1,14 +1,13 @@ -import itertools - import pytest import tensorflow as tf from common.tflite_layer_test_class import TFLiteLayerTest -from tensorflow_lite_tests.test_tfl_Unary import data_generators +from common.utils.tflite_utils import parametrize_tests test_ops = [ {'op_name': 'EQUAL', 'op_func': tf.math.equal}, - {'op_name': 'FLOOR_MOD', 'op_func': tf.math.floormod}, + {'op_name': 'FLOOR_MOD', 'op_func': tf.math.floormod, 'kwargs_to_prepare_input': 'positive'}, + {'op_name': 'FLOOR_DIV', 'op_func': tf.math.floordiv, 'kwargs_to_prepare_input': 'positive'}, {'op_name': 'GREATER', 'op_func': tf.math.greater}, {'op_name': 'GREATER_EQUAL', 'op_func': tf.math.greater_equal}, {'op_name': 'LESS', 'op_func': tf.math.less}, @@ -27,21 +26,13 @@ test_params = [ {'shape': [2, 10]} ] -test_data = list(itertools.product(test_ops, test_params)) -for i, (parameters, shapes) in enumerate(test_data): - parameters.update(shapes) - test_data[i] = parameters.copy() +test_data = parametrize_tests(test_ops, test_params) class TestTFLiteBinaryLayerTest(TFLiteLayerTest): inputs = ["Input_0", "Input_1"] outputs = ["BinaryOperation"] - def _prepare_input(self, inputs_dict, generator=None): - if generator is None: - return super()._prepare_input(inputs_dict) - return data_generators[generator](inputs_dict) - def make_model(self, params): assert len(set(params.keys()).intersection({'op_name', 'op_func', 'shape'})) == 3, \ 'Unexpected parameters for test: ' + ','.join(params.keys()) @@ -49,10 +40,10 @@ class TestTFLiteBinaryLayerTest(TFLiteLayerTest): tf.compat.v1.reset_default_graph() with tf.compat.v1.Session() as sess: place_holder0 = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], - name=TestTFLiteBinaryLayerTest.inputs[0]) + name=self.inputs[0]) place_holder1 = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], - name=TestTFLiteBinaryLayerTest.inputs[1]) - params['op_func'](place_holder0, place_holder1, name=TestTFLiteBinaryLayerTest.outputs[0]) + name=self.inputs[1]) + params['op_func'](place_holder0, place_holder1, name=self.outputs[0]) net = sess.graph_def return net diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_BinaryWithActivation.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_BinaryWithActivation.py index e48fd150191..1e44bfdb6b0 100644 --- a/tests/layer_tests/tensorflow_lite_tests/test_tfl_BinaryWithActivation.py +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_BinaryWithActivation.py @@ -1,10 +1,9 @@ -import itertools - -import tensorflow as tf import pytest +import tensorflow as tf from common.tflite_layer_test_class import TFLiteLayerTest -from common.utils.tflite_utils import data_generators, additional_test_params, activation_helper +from common.utils.tflite_utils import additional_test_params, activation_helper +from common.utils.tflite_utils import parametrize_tests test_ops = [ {'op_name': 'ADD', 'op_func': tf.math.add}, @@ -18,41 +17,26 @@ test_params = [ {'shape': [2, 10]} ] - -test_data = list(itertools.product(test_ops, test_params)) -for i, (parameters, shapes) in enumerate(test_data): - parameters.update(shapes) - test_data[i] = parameters.copy() - -test_data = list(itertools.product(test_data, additional_test_params[1])) -for i, (parameters, additional_test_params[1]) in enumerate(test_data): - parameters.update(additional_test_params[1]) - test_data[i] = parameters.copy() +test_data = parametrize_tests(test_ops, test_params) +test_data = parametrize_tests(test_data, additional_test_params[1]) class TestTFLiteBinaryWithActivationLayerTest(TFLiteLayerTest): inputs = ["Input_0", "Input_1"] outputs = ["BinaryOperation"] - def _prepare_input(self, inputs_dict, generator=None): - if generator is None: - return super()._prepare_input(inputs_dict) - return data_generators[generator](inputs_dict) - def make_model(self, params): assert len(set(params.keys()).intersection({'op_name', 'op_func', 'shape', 'activation'})) == 4, \ 'Unexpected parameters for test: ' + ','.join(params.keys()) self.allowed_ops = [params['op_name']] tf.compat.v1.reset_default_graph() with tf.compat.v1.Session() as sess: - in0 = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], - name=TestTFLiteBinaryWithActivationLayerTest.inputs[0]) - in1 = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], - name=TestTFLiteBinaryWithActivationLayerTest.inputs[1]) - bin_op_name = TestTFLiteBinaryWithActivationLayerTest.outputs[0] if not params['activation'] else \ - TestTFLiteBinaryWithActivationLayerTest.outputs[0] + "/op" + in0 = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], name=self.inputs[0]) + in1 = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], name=self.inputs[1]) + bin_op_name = self.outputs[0] if not params['activation'] else \ + self.outputs[0] + "/op" op = params['op_func'](in0, in1, name=bin_op_name) - op = activation_helper(op, params['activation'], TestTFLiteBinaryWithActivationLayerTest.outputs[0]) + op = activation_helper(op, params['activation'], self.outputs[0]) net = sess.graph_def return net diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_BroadcastArgs.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_BroadcastArgs.py new file mode 100644 index 00000000000..6659935ab07 --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_BroadcastArgs.py @@ -0,0 +1,42 @@ +import numpy as np +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [1, 5], 'broadcast_shape': [5, 5]}, + {'shape': [1], 'broadcast_shape': [7]} +] + + +class TestTFLiteBroadcastArgsLayerTest(TFLiteLayerTest): + inputs = ["Input", "Input1"] + outputs = ["BroadcastArgsOP"] + allowed_ops = ['BROADCAST_ARGS'] + + def _prepare_input(self, inputs_dict, generator=None): + inputs_dict["Input"] = np.array(self.shape).astype(np.int32) + inputs_dict["Input1"] = np.array(self.broadcast_shape).astype(np.int32) + return inputs_dict + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'broadcast_shape'})) == 2, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + self.shape = params['shape'] + self.broadcast_shape = params['broadcast_shape'] + + with tf.compat.v1.Session() as sess: + s0 = tf.compat.v1.placeholder(params.get('dtype', tf.int32), [len(self.shape)], + name=self.inputs[0]) + s1 = tf.compat.v1.placeholder(params.get('dtype', tf.int32), [len(self.shape)], + name=self.inputs[1]) + tf.raw_ops.BroadcastArgs(s0=s0, s1=s1, name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_broadcast_args(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_BroadcastTo.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_BroadcastTo.py new file mode 100644 index 00000000000..bae3f51ce97 --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_BroadcastTo.py @@ -0,0 +1,33 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [1, 1, 1, 1, 40], 'broadcast_shape': [1, 1, 56, 56, 40]}, + {'shape': [1, 1, 1, 1, 10], 'broadcast_shape': [1, 1, 10, 10, 10]} +] + + +class TestTFLiteBroadcastToLayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["BroadcastToOP"] + allowed_ops = ['BROADCAST_TO'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'broadcast_shape'})) == 2, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + place_holder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], + name=self.inputs[0]) + shape_of = tf.reshape(place_holder, params['shape']) + tf.broadcast_to(input=shape_of, shape=params['broadcast_shape'], + name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_broadcast_to(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_Concat.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Concat.py new file mode 100644 index 00000000000..5127deaed0a --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Concat.py @@ -0,0 +1,39 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shapes': [[1, 3], [1, 7]], 'axis': -1}, + {'shapes': [[1, 3, 10], [1, 3, 56], [1, 3, 2]], 'axis': -1}, + {'shapes': [[1, 3, 10, 17], [1, 3, 10, 1], [1, 3, 10, 5], [1, 3, 10, 3]], 'axis': -1}, + {'shapes': [[2, 7], [2, 8]], 'axis': 1}, + {'shapes': [[1, 3, 10], [1, 2, 10], [1, 5, 10]], 'axis': 1}, + {'shapes': [[1, 3, 10, 17], [1, 10, 10, 17], [1, 12, 10, 17], [1, 1, 10, 17]], 'axis': 1}, +] + + +class TestTFLiteConcatTest(TFLiteLayerTest): + outputs = ['Concat'] + allowed_ops = ['CONCATENATION'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shapes', 'axis'})) == 2, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + placeholders = [] + self.inputs = [] + for j, placeholder_shape in enumerate(params['shapes']): + concat_input = f'concat_input_{j}' + self.inputs.append(concat_input) + placeholders.append(tf.compat.v1.placeholder(params.get('dtype', tf.float32), placeholder_shape, + name=concat_input)) + tf.concat(placeholders, params['axis'], name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_concat(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_Conv2D.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Conv2D.py new file mode 100644 index 00000000000..52a03a982f6 --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Conv2D.py @@ -0,0 +1,43 @@ +import numpy as np +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +np.random.seed(42) + +test_params = [ + {'shape': [1, 22, 22, 8], 'ksize': [32, 3, 4, 4], 'strides': 2, 'padding': 'SAME', 'data_format': 'NHWC', + 'dilations': [1, 1, 1, 1]}, + {'shape': [1, 22, 22, 9], 'ksize': [32, 3, 3, 3], 'strides': (2, 1), 'padding': 'SAME', 'data_format': 'NHWC', + 'dilations': [1, 2, 2, 1]}, + {'shape': [1, 22, 22, 8], 'ksize': [1, 3, 4, 4], 'strides': 2, 'padding': 'VALID', 'data_format': 'NHWC', + 'dilations': [1, 1, 1, 1]}, + {'shape': [1, 22, 22, 3], 'ksize': [1, 3, 3, 3], 'strides': (3, 4), 'padding': 'VALID', 'data_format': 'NHWC', + 'dilations': [1, 2, 2, 1]}, +] + + +class TestTFLiteConv2DLayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["Conv2D"] + allowed_ops = ['CONV_2D'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'ksize', 'strides', + 'padding', 'data_format', 'dilations'})) == 6, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + weights = tf.constant(np.random.randint(-1, 1, params['ksize']), dtype=tf.float32) + place_holder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], + name=self.inputs[0]) + tf.nn.conv2d(place_holder, weights, params['strides'], params['padding'], params['data_format'], + params['dilations'], name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_conv2d(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_DepthToSpace.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_DepthToSpace.py new file mode 100644 index 00000000000..e50b22fa132 --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_DepthToSpace.py @@ -0,0 +1,31 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [8, 10, 10, 16], 'block_size': 2, 'data_format': 'NHWC'}, + {'shape': [24, 10, 10, 50], 'block_size': 5, 'data_format': 'NHWC'}, +] + + +class TestTFLiteDepthToSpaceLayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["DepthToSpace"] + allowed_ops = ['DEPTH_TO_SPACE'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'block_size', 'data_format'})) == 3, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + place_holder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], + name=self.inputs[0]) + tf.nn.depth_to_space(place_holder, params['block_size'], params['data_format'], name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_depth_to_space(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_DepthwiseConv2D.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_DepthwiseConv2D.py new file mode 100644 index 00000000000..24f8023975c --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_DepthwiseConv2D.py @@ -0,0 +1,39 @@ +import numpy as np +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +np.random.seed(42) + +test_params = [ + {'shape': [1, 22, 22, 8], 'ksize': [3, 3, 8, 2], 'strides': [1, 2, 2, 1], 'padding': 'SAME', 'data_format': 'NHWC', + 'dilations': [1, 1]}, + {'shape': [1, 22, 22, 9], 'ksize': [3, 3, 9, 1], 'strides': [1, 1, 1, 1], 'padding': 'SAME', 'data_format': 'NHWC', + 'dilations': [1, 1]}, +] + + +class TestTFLiteDepthwiseConv2DLayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["DepthwiseConv2D"] + allowed_ops = ['DEPTHWISE_CONV_2D'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'ksize', 'strides', + 'padding', 'data_format', 'dilations'})) == 6, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + weights = tf.constant(np.random.randint(-1, 1, params['ksize']), dtype=tf.float32) + place_holder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], + name=self.inputs[0]) + tf.nn.depthwise_conv2d(place_holder, weights, params['strides'], params['padding'], params['data_format'], + params['dilations'], name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_depthwise_conv2d(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_Fill.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Fill.py new file mode 100644 index 00000000000..3fdbaedcadb --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Fill.py @@ -0,0 +1,32 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [2, 3], 'value': 1, 'kwargs_to_prepare_input': 'int32_positive'}, + {'shape': [2, 3, 3, 4], 'value': -1, 'kwargs_to_prepare_input': 'int32_positive'}, + {'shape': [1], 'value': 0, 'kwargs_to_prepare_input': 'int32_positive'} +] + + +class TestTFLiteBroadcastToLayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["Fill"] + allowed_ops = ['FILL'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'value'})) == 2, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + placeholder = tf.compat.v1.placeholder(params.get('dtype', tf.int32), [len(params['shape'])], + name=self.inputs[0]) + tf.fill(placeholder, params['value'], name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_fill(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_FullyConnected.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_FullyConnected.py new file mode 100644 index 00000000000..5b5d522c5fe --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_FullyConnected.py @@ -0,0 +1,35 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape_x': [40, 37], 'shape_y': [37, 37], 'transpose_a': False, 'transpose_b': True}, + {'shape_x': [5, 5], 'shape_y': [4, 5], 'transpose_a': False, 'transpose_b': True}, + {'shape_x': [1, 5, 5], 'shape_y': [4, 5], 'transpose_a': False, 'transpose_b': True}, +] + + +class TestTFLiteFullyConnectedLayerTest(TFLiteLayerTest): + inputs = ["Input_x", "Input_y"] + outputs = ["FullyConnected"] + allowed_ops = ['FULLY_CONNECTED'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape_x', 'shape_y', + 'transpose_a', 'transpose_b'})) == 4, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + x = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape_x'], name=self.inputs[0]) + y = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape_y'], name=self.inputs[1]) + + tf.matmul(x, y, transpose_a=params['transpose_a'], transpose_b=params['transpose_b'], + name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_fully_connected(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_Gather.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Gather.py new file mode 100644 index 00000000000..ba6747fe6a5 --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Gather.py @@ -0,0 +1,38 @@ +import numpy as np +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +np.random.seed(42) + +test_params = [ + {'shape': [1, 10], 'indices_shape': [1, 5]}, + {'shape': [2, 3, 5, 5], 'indices_shape': [4, 5]}, + {'shape': [1, 5, 5], 'indices_shape': [2, 4, 5]}, + {'shape': [1, 5, 5], 'indices_shape': [2, 4, 5, 6]}, +] + + +class TestTFLiteGatherLayerTest(TFLiteLayerTest): + inputs = ["Input_x"] + outputs = ["Gather"] + allowed_ops = ['GATHER'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'indices_shape', })) == 2, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + placeholder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), + params['shape'], name=self.inputs[0]) + constant = tf.constant(np.random.randint(0, 1, size=params['indices_shape'])) + + tf.gather(placeholder, constant, name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_gather(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_GatherND.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_GatherND.py new file mode 100644 index 00000000000..4952483df87 --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_GatherND.py @@ -0,0 +1,50 @@ +import numpy as np +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [5, 1], 'indices_shape': [1, 1], 'batch_dims': 0}, + + {'shape': [5, 5], 'indices_shape': [2, 1], 'batch_dims': 0}, + {'shape': [5, 5], 'indices_shape': [2, 2], 'batch_dims': 0}, + # + {'shape': [3, 5, 10], 'indices_shape': [3, 2], 'batch_dims': 1}, + {'shape': [5, 5, 10], 'indices_shape': [2, 3], 'batch_dims': 0}, + {'shape': [4, 5, 10], 'indices_shape': [2, 10, 1], 'batch_dims': 2}, + ] + + +class TestTFLiteGatherLayerTest(TFLiteLayerTest): + inputs = ["Input_x"] + outputs = ["GatherND"] + allowed_ops = ['GATHER_ND'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'indices_shape', 'batch_dims'})) == 3, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + self.outputs = ["GatherND"] + self.allowed_ops = ["GATHER_ND"] + if params['batch_dims'] > 0: + output_name = "GatherND" + self.outputs = [f"GatherND/Reshape_{params['batch_dims'] + 2}"] + if params['batch_dims'] > 1: + self.allowed_ops.append('RESHAPE') + else: + output_name = self.outputs[0] + + with tf.compat.v1.Session() as sess: + placeholder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), + params['shape'], name=self.inputs[0]) + constant = tf.constant(np.random.randint(0, params['shape'][0] - 1, params['indices_shape'])) + + tf.gather_nd(placeholder, constant, name=output_name, batch_dims=params['batch_dims']) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_gather_nd(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_L2Normalization.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_L2Normalization.py new file mode 100644 index 00000000000..569a7039e85 --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_L2Normalization.py @@ -0,0 +1,37 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest +from common.utils.tflite_utils import additional_test_params +from common.utils.tflite_utils import parametrize_tests + +test_params = [ + {'shape': [1]}, + {'shape': [1, 22]}, + {'shape': [1, 1, 8]}, + {'shape': [1, 22, 22, 8]}, +] + +test_data = parametrize_tests(test_params, additional_test_params[0]) + + +class TestTFLiteExpandDimsLayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["L2_Normalization"] + allowed_ops = ['L2_NORMALIZATION'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape'})) == 1, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + place_holder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], + name=self.inputs[0]) + tf.math.l2_normalize(place_holder, axis=params['axis'], name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_data) + @pytest.mark.nightly + def test_l2_normalization(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_MatrixDiag.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_MatrixDiag.py new file mode 100644 index 00000000000..61e0461832f --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_MatrixDiag.py @@ -0,0 +1,34 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [3]}, + {'shape': [1, 22]}, + {'shape': [1, 1, 8]}, + {'shape': [1, 22, 22, 8]}, + {'shape': [1, 22, 22, 8, 3]}, +] + + +class TestTFLiteMatrixDiagLayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["MatrixDiag"] + allowed_ops = ['MATRIX_DIAG'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape'})) == 1, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + place_holder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], + name=self.inputs[0]) + tf.linalg.diag(place_holder, name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_matrix_diag(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_MirrorPad.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_MirrorPad.py new file mode 100644 index 00000000000..3adb81d2c4a --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_MirrorPad.py @@ -0,0 +1,39 @@ +import numpy as np +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [2, 3], 'padding_matrix': [[1, 1], [2, 1]], 'mode': 'REFLECT'}, + {'shape': [2, 3], 'padding_matrix': [[1, 1], [1, 1]], 'mode': 'REFLECT'}, + {'shape': [2, 3], 'padding_matrix': [[1, 1], [2, 1]], 'mode': 'SYMMETRIC'}, + + {'shape': [3], 'padding_matrix': [[0, 2]], 'mode': 'SYMMETRIC'}, + {'shape': [3], 'padding_matrix': [[0, 2]], 'mode': 'REFLECT'}, + + {'shape': [3, 2, 4, 5], 'padding_matrix': [[1, 1], [2, 2], [1, 1], [1, 1]], 'mode': 'SYMMETRIC'}, +] + + +class TestTFLiteMirrorPadLayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["MirrorPad"] + allowed_ops = ['MIRROR_PAD'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'padding_matrix', 'mode'})) == 3, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + place_holder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], + name=self.inputs[0]) + padding_matrix = tf.constant(np.array(params["padding_matrix"])) + tf.pad(tensor=place_holder, paddings=padding_matrix, mode=params['mode'], name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_mirror_pad(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_OneHot.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_OneHot.py new file mode 100644 index 00000000000..84debdbe9ce --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_OneHot.py @@ -0,0 +1,38 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [3], 'axis': 0, 'kwargs_to_prepare_input': 'int32_positive'}, + {'shape': [4, 4], 'axis': 1, 'kwargs_to_prepare_input': 'int32_positive'}, + {'shape': [1, 5, 3], 'axis': 0, 'kwargs_to_prepare_input': 'int32_positive'}, + {'shape': [5, 1, 2, 4], 'axis': 1, 'kwargs_to_prepare_input': 'int32_positive'}, +] + + +class TestTFLiteOneHotLayerTest(TFLiteLayerTest): + inputs = ['Indices', 'Depth', 'OnValue', 'OffValue'] + outputs = ["OneHot"] + allowed_ops = ['ONE_HOT'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'axis'})) == 1, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + indices = tf.compat.v1.placeholder(dtype=tf.int32, name=self.inputs[0], shape=params["shape"]) + depth = tf.compat.v1.placeholder(dtype=tf.int32, name=self.inputs[1], shape=()) + + on_value = tf.compat.v1.placeholder(dtype=tf.int32, name=self.inputs[2], shape=()) + off_value = tf.compat.v1.placeholder(dtype=tf.int32, name=self.inputs[3], shape=()) + + tf.one_hot(indices=indices, depth=depth, on_value=on_value, off_value=off_value, + axis=params['axis'], name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_one_hot(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_Pack.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Pack.py new file mode 100644 index 00000000000..0310383166a --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Pack.py @@ -0,0 +1,40 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [3], 'num_tensors': 2}, + {'shape': [1, 22], 'num_tensors': 10}, + {'shape': [1, 1, 8], 'num_tensors': 5}, + {'shape': [1, 22, 22, 8], 'num_tensors': 5}, + {'shape': [1, 22, 22, 8, 3], 'num_tensors': 7}, +] + + +class TestTFLitePackLayerTest(TFLiteLayerTest): + inputs = [] + outputs = ["Pack"] + allowed_ops = ['PACK'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'num_tensors'})) == 2, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + tensors = [] + self.inputs = [] + for j in range(params['num_tensors']): + name = f'Input_{j}' + self.inputs.append(name) + place_holder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], + name=name) + tensors.append(place_holder) + tf.stack(tensors, name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_pack(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_Pad.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Pad.py new file mode 100644 index 00000000000..37a7362311b --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Pad.py @@ -0,0 +1,43 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [1, 1, 2, 1, 1], 'paddings': [[0, 0], [0, 1], [2, 3], [0, 0], [1, 0]]}, + {'shape': [2, 1, 1, 1, 1], 'paddings': [[0, 1], [0, 0], [0, 0], [2, 3], [1, 0]]}, + + {'shape': [1, 1, 2, 1], 'paddings': [[0, 0], [0, 1], [2, 3], [0, 0]]}, + {'shape': [1, 1, 2, 1], 'paddings': [[0, 0], [0, 1], [2, 3], [0, 0]]}, + + {'shape': [1, 2], 'paddings': [[0, 1], [2, 1]]}, + {'shape': [1, 2], 'paddings': [[2, 3], [0, 1]]}, + + {'shape': [1], 'paddings': [[1, 2]]}, + +] + + +class TestTFLitePadLayerTest(TFLiteLayerTest): + inputs = ["Input", 'Paddings'] + outputs = ["Pad"] + allowed_ops = ['PAD'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'paddings'})) == 2, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + place_holder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], + name=self.inputs[0]) + shape = [len(params["paddings"]), 2] + paddings = tf.compat.v1.placeholder(dtype=tf.int32, name=self.inputs[1], shape=shape) + tf.pad(tensor=place_holder, paddings=paddings, name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_pad(self, params, ie_device, precision, temp_dir): + pytest.xfail("CVS-110828") + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_Pool.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Pool.py new file mode 100644 index 00000000000..a67097628e2 --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Pool.py @@ -0,0 +1,44 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest +from common.utils.tflite_utils import parametrize_tests + +test_ops = [ + {'op_name': 'AVERAGE_POOL_2D', 'op_func': tf.nn.avg_pool2d}, + {'op_name': 'MAX_POOL_2D', 'op_func': tf.nn.max_pool2d}, +] + +test_params = [ + # TFLite doesn't support avgpool with 'NCHW' format + {'shape': [1, 22, 22, 8], 'ksize': [3, 3], 'strides': 2, 'padding': 'SAME', 'data_format': 'NHWC'}, + {'shape': [1, 22, 22, 8], 'ksize': [3, 3], 'strides': (2, 1), 'padding': 'SAME', 'data_format': 'NHWC'}, + {'shape': [1, 22, 22, 8], 'ksize': [3, 3], 'strides': 2, 'padding': 'VALID', 'data_format': 'NHWC'}, + {'shape': [1, 22, 22, 8], 'ksize': [3, 3], 'strides': (3, 4), 'padding': 'VALID', 'data_format': 'NHWC'}, +] + +test_data = parametrize_tests(test_ops, test_params) + + +class TestTFLitePoolLayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["Pool"] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'op_name', 'op_func', 'shape', 'ksize', 'strides', + 'padding', 'data_format'})) == 7, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + self.allowed_ops = [params['op_name']] + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + place_holder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], + name=self.inputs[0]) + params['op_func'](place_holder, params['ksize'], params['strides'], + params['padding'], params['data_format'], name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_data) + @pytest.mark.nightly + def test_pool(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_RFFT2D.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_RFFT2D.py new file mode 100644 index 00000000000..b534878970a --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_RFFT2D.py @@ -0,0 +1,34 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [96, 1, 512], 'fft_length': [1, 512], 'reshape_to': [96, 257]}, + {'shape': [5, 1, 16], 'fft_length': [1, 16], 'reshape_to': [5, 9]}, +] + + +class TestTFLiteRFFT2DLayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ['RFFT2D_1'] + allowed_ops = ['COMPLEX_ABS', 'RESHAPE', 'RFFT2D'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'fft_length', 'reshape_to'})) == 3, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + placeholder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], + name=self.inputs[0]) + rfft_2d = tf.signal.rfft2d(placeholder, fft_length=params["fft_length"]) + reshape = tf.reshape(rfft_2d, params['reshape_to']) + out = tf.raw_ops.ComplexAbs(x=reshape, Tout=tf.float32, name='RFFT2D') + + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_rfft2d(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_Range.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Range.py new file mode 100644 index 00000000000..9496bee1021 --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Range.py @@ -0,0 +1,52 @@ +import numpy as np +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +np.random.seed(42) + +test_params = [ + {'dtype': np.float32, 'negative_delta': False}, + {'dtype': np.int32, 'negative_delta': True}, +] + + +class TestTFLiteRangeLayerTest(TFLiteLayerTest): + inputs = ['Start', 'Limit', 'Delta'] + outputs = ["Range"] + allowed_ops = ['RANGE'] + + def _prepare_input(self, inputs_dict, generator=None): + inputs_data = {} + if self.negative_delta: + inputs_data['Start'] = np.random.randint(1, 10, []).astype(self.dtype) + inputs_data['Limit'] = np.random.randint(-10, 0, []).astype(self.dtype) + inputs_data['Delta'] = np.random.randint(-5, -1, []).astype(self.dtype) + else: + inputs_data['Start'] = np.random.randint(1, 10, []).astype(self.dtype) + inputs_data['Limit'] = np.random.randint(10, 30, []).astype(self.dtype) + inputs_data['Delta'] = np.random.randint(1, 5, []).astype(self.dtype) + + return inputs_data + + def make_model(self, params): + assert len(set(params.keys()).intersection({'dtype', 'negative_delta'})) == 2, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + self.dtype = params['dtype'] + self.negative_delta = params['negative_delta'] + + start = tf.compat.v1.placeholder(self.dtype, [], self.inputs[0]) + limit = tf.compat.v1.placeholder(self.dtype, [], self.inputs[1]) + delta = tf.compat.v1.placeholder(self.dtype, [], self.inputs[2]) + + tf.range(start, limit, delta, name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_range(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_Reduce.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Reduce.py index 71488370596..6a2c1449f52 100644 --- a/tests/layer_tests/tensorflow_lite_tests/test_tfl_Reduce.py +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Reduce.py @@ -1,10 +1,9 @@ -import itertools - import pytest import tensorflow as tf from common.tflite_layer_test_class import TFLiteLayerTest -from common.utils.tflite_utils import data_generators, additional_test_params +from common.utils.tflite_utils import additional_test_params +from common.utils.tflite_utils import parametrize_tests test_ops = [ {'op_name': 'MEAN', 'op_func': tf.math.reduce_mean}, @@ -21,28 +20,14 @@ test_params = [ {'shape': [2, 10]} ] - -test_data = list(itertools.product(test_ops, test_params)) -for i, (parameters, shapes) in enumerate(test_data): - parameters.update(shapes) - test_data[i] = parameters.copy() - - -test_data = list(itertools.product(test_data, additional_test_params[0])) -for i, (parameters, additional_test_params[0]) in enumerate(test_data): - parameters.update(additional_test_params[0]) - test_data[i] = parameters.copy() +test_data = parametrize_tests(test_ops, test_params) +test_data = parametrize_tests(test_data, additional_test_params[0]) class TestTFLiteReduceLayerTest(TFLiteLayerTest): inputs = ["Input"] outputs = ["ReduceOperation"] - def _prepare_input(self, inputs_dict, generator=None): - if generator is None: - return super()._prepare_input(inputs_dict) - return data_generators[generator](inputs_dict) - def make_model(self, params): assert len(set(params.keys()).intersection({'op_name', 'op_func', 'shape', 'axis'})) == 4, \ 'Unexpected parameters for test: ' + ','.join(params.keys()) @@ -50,8 +35,8 @@ class TestTFLiteReduceLayerTest(TFLiteLayerTest): tf.compat.v1.reset_default_graph() with tf.compat.v1.Session() as sess: place_holder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], - name=TestTFLiteReduceLayerTest.inputs[0]) - params['op_func'](place_holder, axis=params['axis'], name=TestTFLiteReduceLayerTest.outputs[0]) + name=self.inputs[0]) + params['op_func'](place_holder, axis=params['axis'], name=self.outputs[0]) net = sess.graph_def return net diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_Reshape.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Reshape.py new file mode 100644 index 00000000000..dcc56819148 --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Reshape.py @@ -0,0 +1,34 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [2, 6], 'out_shape': [2, 3, 2]}, + {'shape': [2, 4, 6], 'out_shape': [2, -1]}, + {'shape': [1], 'out_shape': []}, +] + + +class TestTFLiteReshapeLayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["Reshape"] + allowed_ops = ['RESHAPE'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'out_shape'})) == 2, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + place_holder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], + name=self.inputs[0]) + out_shape = tf.constant(params['out_shape'], dtype=tf.int32) + + tf.reshape(place_holder, out_shape, name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_reshape(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_Resize.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Resize.py new file mode 100644 index 00000000000..5c37153e965 --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Resize.py @@ -0,0 +1,50 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest +from common.utils.tflite_utils import parametrize_tests + +test_ops = [ + {'op_name': ['RESIZE_BILINEAR'], 'op_func': tf.compat.v1.image.resize_bilinear}, + {'op_name': ['RESIZE_NEAREST_NEIGHBOR'], 'op_func': tf.compat.v1.image.resize_nearest_neighbor}, +] + +test_params = [ + {'shape': [1, 3, 4, 3], 'size': [1, 1], 'align_corners': True, 'half_pixel_centers': False}, + {'shape': [1, 3, 4, 3], 'size': [1, 1], 'align_corners': False, 'half_pixel_centers': False}, + {'shape': [1, 3, 4, 3], 'size': [1, 1], 'align_corners': False, 'half_pixel_centers': True}, # accuracy failure + + {'shape': [1, 3, 4, 3], 'size': [10, 10], 'align_corners': True, 'half_pixel_centers': False}, + {'shape': [1, 3, 4, 3], 'size': [10, 10], 'align_corners': False, 'half_pixel_centers': False}, + {'shape': [1, 3, 4, 3], 'size': [10, 10], 'align_corners': False, 'half_pixel_centers': True}, # accuracy failure +] + +test_data = parametrize_tests(test_ops, test_params) + + +class TestTFLiteResizeLayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["Resize"] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'op_name', 'op_func', 'shape', 'size', 'align_corners', + 'half_pixel_centers'})) == 6, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + self.allowed_ops = params['op_name'] + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + placeholder = tf.compat.v1.placeholder(params.get("dtype", tf.float32), params["shape"], + name=self.inputs[0]) + params['op_func'](placeholder, size=params['size'], + align_corners=params['align_corners'], + half_pixel_centers=params['half_pixel_centers'], + name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_data) + @pytest.mark.nightly + def test_resize_resize(self, params, ie_device, precision, temp_dir): + if not params['align_corners'] and params['half_pixel_centers'] and params['op_name'] == ['RESIZE_NEAREST_NEIGHBOR']: + pytest.xfail("CVS-110473") + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_ReverseV2.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_ReverseV2.py new file mode 100644 index 00000000000..66a61594547 --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_ReverseV2.py @@ -0,0 +1,43 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [1], 'axis': [-1]}, + {'shape': [1], 'axis': [0]}, + {'shape': [2, 6], 'axis': [-1, -2]}, + {'shape': [2, 6], 'axis': [1]}, + {'shape': [2, 4, 6], 'axis': [0, -2]}, + {'shape': [2, 4, 6], 'axis': [2]}, + {'shape': [2, 4, 6, 8], 'axis': [0, 3, -3, 2]}, + {'shape': [2, 4, 6, 8], 'axis': [-3]}, + {'shape': [2, 3, 1, 2, 2], 'axis': [0, 3, -3, 1, -1]}, + {'shape': [2, 3, 1, 2, 2], 'axis': [4]}, + {'shape': [2, 1, 1, 1, 2, 3, 2, 2], 'axis': [-1]}, + {'shape': [2, 1, 1, 1, 2, 3, 2, 2], 'axis': [0, 1, 2, 3, 4, 5, 6, 7]}, +] + + +class TestTFLiteReverseV2LayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["ReverseV2"] + allowed_ops = ['REVERSE_V2'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'axis'})) == 2, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + place_holder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], + name=self.inputs[0]) + tf.reverse(place_holder, params['axis'], name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_reverse_v2(self, params, ie_device, precision, temp_dir): + if len(params['axis']) > 1: + pytest.xfail('CVS-109932') + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_ScatterND.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_ScatterND.py new file mode 100644 index 00000000000..d2393dc4aa5 --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_ScatterND.py @@ -0,0 +1,74 @@ +import numpy as np +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +np.random.seed(42) + +test_params = [ + {'indices_shape': [4, 1], 'indices_value': [4, 3, 1, 7], 'updates_dtype': np.int32, 'updates_shape': [4], + 'shape_shape': [1], 'shape_value': [8]}, + {'indices_shape': [4, 1], 'indices_value': [4, 3, 1, 7], 'updates_dtype': np.int64, 'updates_shape': [4], + 'shape_shape': [1], 'shape_value': [8]}, + {'indices_shape': [4, 1], 'indices_value': [4, 3, 1, 7], 'updates_dtype': np.float32, 'updates_shape': [4], + 'shape_shape': [1], 'shape_value': [8]}, + {'indices_shape': [4, 1], 'indices_value': [4, 3, 1, 7], 'updates_dtype': np.bool, 'updates_shape': [4], + 'shape_shape': [1], 'shape_value': [8]}, + + {'indices_shape': [4, 2], 'indices_value': [[0, 0], [1, 0], [0, 2], [1, 2]], 'updates_dtype': np.int32, + 'updates_shape': [4, 5], 'shape_shape': [3], 'shape_value': [2, 3, 5]}, + {'indices_shape': [4, 2], 'indices_value': [[0, 0], [1, 0], [0, 2], [1, 2]], 'updates_dtype': np.int64, + 'updates_shape': [4, 5], 'shape_shape': [3], 'shape_value': [2, 3, 5]}, + {'indices_shape': [4, 2], 'indices_value': [[0, 0], [1, 0], [0, 2], [1, 2]], 'updates_dtype': np.float32, + 'updates_shape': [4, 5], 'shape_shape': [3], 'shape_value': [2, 3, 5]}, + {'indices_shape': [4, 2], 'indices_value': [[0, 0], [1, 0], [0, 2], [1, 2]], 'updates_dtype': np.bool, + 'updates_shape': [4, 5], 'shape_shape': [3], 'shape_value': [2, 3, 5]}, +] + + +class TestTFLiteScatterNDLayerTest(TFLiteLayerTest): + inputs = ["Indices", "Updates", "Shape"] + outputs = ["ScatterND"] + allowed_ops = ['SCATTER_ND'] + + def _prepare_input(self, inputs_dict, generator=None): + inputs_dict['Indices'] = np.array(self.indices_value, dtype=np.int32).reshape(self.indices_shape) + + if self.updates_dtype in [tf.int32, tf.int64]: + inputs_dict['Updates'] = np.random.randint(-100, 100 + 1, self.updates_shape) + if self.updates_dtype == tf.float32: + inputs_dict['Updates'] = (100 - (-100) * np.random.random_sample(self.updates_shape) + (-100)) + if self.updates_dtype == tf.bool: + inputs_dict['Updates'] = np.random.choice([True, False], size=self.updates_shape) + + inputs_dict['Updates'] = inputs_dict['Updates'].astype(self.updates_dtype) + inputs_dict['Shape'] = np.array(self.shape_value, dtype=np.int32) + + return inputs_dict + + def make_model(self, params): + assert len(set(params.keys()).intersection({'indices_shape', 'indices_value', + 'updates_dtype', 'updates_shape', 'shape_shape', + 'shape_value'})) == 6, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + self.indices_value = params['indices_value'] + self.indices_shape = params['indices_shape'] + self.updates_dtype = params['updates_dtype'] + self.updates_shape = params['updates_shape'] + self.shape_value = params['shape_value'] + + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + indices = tf.compat.v1.placeholder(tf.int32, self.indices_shape, name=self.inputs[0]) + updates = tf.compat.v1.placeholder(self.updates_dtype, self.updates_shape, name=self.inputs[1]) + shape = tf.compat.v1.placeholder(tf.int32, params['shape_shape'], name=self.inputs[2]) + + tf.scatter_nd(indices, updates, shape, name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_scatter_nd(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_SegmentSum.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_SegmentSum.py new file mode 100644 index 00000000000..a5ce2d314ae --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_SegmentSum.py @@ -0,0 +1,44 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [4], 'segment_ids': [0, 0, 1, 1]}, + {'shape': [4], 'segment_ids': [0, 1, 2, 2]}, + {'shape': [4], 'segment_ids': [0, 1, 2, 3]}, + {'shape': [4], 'segment_ids': [0, 0, 0, 0]}, + + {'shape': [4, 4], 'segment_ids': [0, 0, 1, 1]}, + {'shape': [4, 4], 'segment_ids': [0, 1, 2, 2]}, + {'shape': [4, 4], 'segment_ids': [0, 1, 2, 3]}, + {'shape': [4, 4], 'segment_ids': [0, 0, 0, 0]}, + + {'shape': [4, 3, 2], 'segment_ids': [0, 0, 0, 0]}, + {'shape': [4, 3, 2], 'segment_ids': [0, 0, 1, 1]}, + {'shape': [4, 3, 2], 'segment_ids': [0, 1, 2, 2]}, + {'shape': [4, 3, 2], 'segment_ids': [0, 1, 2, 3]}, +] + + +class TestTFLiteSegmentSumLayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["SegmentSum"] + allowed_ops = ['SEGMENT_SUM'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'segment_ids'})) == 2, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + place_holder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], + name=self.inputs[0]) + constant = tf.constant(params['segment_ids'], dtype=tf.int32) + tf.math.segment_sum(place_holder, constant, name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_segment_sum(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_Select.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Select.py new file mode 100644 index 00000000000..dff7cffde0a --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Select.py @@ -0,0 +1,35 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [2, 3, 1, 2, 2], 'condition': [True, False]}, + {'shape': [4, 3, 1, 2], 'condition': [False, False, False, True]}, + {'shape': [2, 3], 'condition': [[True, True, True], [False, False, False]]}, + {'shape': [2], 'condition': [False, True]}, +] + + +class TestTFLiteSelectLayerTest(TFLiteLayerTest): + inputs = ["X", "Y"] + outputs = ["Select"] + allowed_ops = ['SELECT'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'condition'})) == 2, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + cond = tf.constant(params['condition'], dtype=tf.bool) + x = tf.compat.v1.placeholder(tf.float32, params['shape'], self.inputs[0]) + y = tf.compat.v1.placeholder(tf.float32, params['shape'], self.inputs[1]) + + tf.raw_ops.Select(condition=cond, x=x, y=y, name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_select(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_SelectV2.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_SelectV2.py new file mode 100644 index 00000000000..b1d1ef29e53 --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_SelectV2.py @@ -0,0 +1,36 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [2, 3, 1, 2, 2], 'condition': [True, False]}, + {'shape': [4, 3, 1, 2], 'condition': [False, True]}, + {'shape': [3, 3, 3, 3], 'condition': [True, True, False]}, + {'shape': [3, 3, 3], 'condition': [True, True, False]}, + {'shape': [2, 3], 'condition': [True, False, True]}, +] + + +class TestTFLiteSelectLayerTest(TFLiteLayerTest): + inputs = ["X", "Y"] + outputs = ["Select"] + allowed_ops = ['SELECT_V2'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'condition'})) == 2, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + cond = tf.constant(params['condition'], dtype=tf.bool) + x = tf.compat.v1.placeholder(tf.float32, params['shape'], self.inputs[0]) + y = tf.compat.v1.placeholder(tf.float32, params['shape'], self.inputs[1]) + + tf.raw_ops.SelectV2(condition=cond, t=x, e=y, name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_select_v2(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_Slice.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Slice.py new file mode 100644 index 00000000000..307a8a216e5 --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Slice.py @@ -0,0 +1,57 @@ +import string + +import numpy as np +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + # OV doesn't support string format + # {'shape': [12, 2, 2, 5], 'begin': [0, 0, 0, 0], 'size': [8, 2, 2, 3], 'dtype': tf.string}, + {'shape': [12, 2, 2, 5], 'begin': [1, 0, 1, 0], 'size': [11, 2, 1, 5], 'dtype': np.float32}, + {'shape': [1, 4, 4, 4], 'begin': [0, 1, 0, 0], 'size': [1, -1, 1, 1], 'dtype': np.float32}, + {'shape': [6, 2, 2, 2, 5], 'begin': [0, 0, 0, 0, 0], 'size': [4, 2, 2, 2, 3], 'dtype': np.int32}, + {'shape': [2, 3], 'begin': [1, 0], 'size': [-1, -1], 'dtype': np.int64}, +] + + +class TestTFLiteSliceLayerTest(TFLiteLayerTest): + inputs = ["Input", "Begin", "Size"] + outputs = ["Slice"] + allowed_ops = ['SLICE'] + + def _prepare_input(self, inputs_dict, generator=None): + if self.input_dtype == tf.string: + letters = list(string.ascii_uppercase) + inputs_dict["Input"] = np.random.choice(letters, size=self.shape).astype(self.input_dtype) + else: + inputs_dict["Input"] = np.random.randint(-1, 2, self.shape).astype(self.input_dtype) + + inputs_dict["Begin"] = np.array(self.begin).astype(np.int32) + inputs_dict['Size'] = np.array(self.size).astype(np.int32) + + return inputs_dict + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'begin', 'size', 'dtype'})) == 4, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + self.input_dtype = params['dtype'] + self.shape = params['shape'] + self.begin = params['begin'] + self.size = params['size'] + + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + placeholder = tf.compat.v1.placeholder(params['dtype'], params['shape'], self.inputs[0]) + begin = tf.compat.v1.placeholder(tf.int32, len(params['shape']), name=self.inputs[1]) + size = tf.compat.v1.placeholder(tf.int32, len(params['shape']), name=self.inputs[2]) + + tf.slice(placeholder, begin, size, name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_slice(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_SpaceToBatchND.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_SpaceToBatchND.py new file mode 100644 index 00000000000..3a6500ed832 --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_SpaceToBatchND.py @@ -0,0 +1,32 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [8, 10, 10, 3], 'block_shape': [2, 2], 'paddings': [[0, 2], [0, 0]]}, + {'shape': [24, 10, 10, 1], 'block_shape': [6, 6], 'paddings': [[2, 0], [0, 2]]} +] + + +class TestTFLiteSpaceToBatchNDLayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["SpaceToBatchOP"] + allowed_ops = ['SPACE_TO_BATCH_ND'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'block_shape', 'paddings'})) == 3, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + place_holder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], + name=self.inputs[0]) + tf.space_to_batch(place_holder, params['block_shape'], params['paddings'], + name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_space_to_batch_nd(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_SpaceToDepth.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_SpaceToDepth.py new file mode 100644 index 00000000000..1c9612160a8 --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_SpaceToDepth.py @@ -0,0 +1,31 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [8, 10, 10, 16], 'block_size': 2, 'data_format': 'NHWC'}, + {'shape': [24, 10, 10, 50], 'block_size': 5, 'data_format': 'NHWC'}, +] + + +class TestTFLiteSpaceToDepthLayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["SpaceToDepth"] + allowed_ops = ['SPACE_TO_DEPTH'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'block_size', 'data_format'})) == 3, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + place_holder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], + name=self.inputs[0]) + tf.nn.space_to_depth(place_holder, params['block_size'], params['data_format'], name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_space_to_depth(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_Split.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Split.py new file mode 100644 index 00000000000..162f25f1d1f --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Split.py @@ -0,0 +1,32 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [6], 'num_or_size_splits': 2, 'axis': 0}, + {'shape': [2, 1, 6], 'num_or_size_splits': 3, 'axis': 2}, + {'shape': [4, 3, 2, 7], 'num_or_size_splits': 4, 'axis': -4}, +] + + +class TestTFLiteSplitLayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["Split"] + allowed_ops = ['SPLIT'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'num_or_size_splits', + 'axis'})) == 3, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + placeholder = tf.compat.v1.placeholder(tf.float32, params['shape'], self.inputs[0]) + tf.split(placeholder, params["num_or_size_splits"], params["axis"], name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_split(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_SplitV.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_SplitV.py new file mode 100644 index 00000000000..1de77f696bf --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_SplitV.py @@ -0,0 +1,39 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [3], 'num_or_size_splits': [0, 2, 0, 1], 'axis': 0}, + {'shape': [2, 3, 9], 'num_or_size_splits': [1, 2, 3, -1, 1], 'axis': 2}, + {'shape': [3, 9, 5, 4], 'num_or_size_splits': [1, 2, 0, -1, 2, 0], 'axis': -3}, +] + + +class TestTFLiteSplitLayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["SplitV"] + allowed_ops = ['SPLIT_V'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'num_or_size_splits', + 'axis'})) == 3, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + placeholder = tf.compat.v1.placeholder(tf.float32, params['shape'], self.inputs[0]) + size_splits = tf.constant(params['num_or_size_splits'], dtype=tf.int32) + axis = tf.constant(params['axis'], dtype=tf.int32) + num_split = len(params['num_or_size_splits']) + + tf.raw_ops.SplitV(value=placeholder, size_splits=size_splits, axis=axis, + num_split=num_split, name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_split_v(self, params, ie_device, precision, temp_dir): + if 0 in params['num_or_size_splits']: + pytest.skip("CVS-110040") + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_StridedSlice.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_StridedSlice.py new file mode 100644 index 00000000000..fea9364b045 --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_StridedSlice.py @@ -0,0 +1,69 @@ +import numpy as np +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [12, 2, 2, 5], 'dtype': np.int32, 'strides': [2, 1, 3, 1], 'begin': [0, 0, 0, 0], 'end': [12, 2, 2, 5], + 'begin_mask': None, 'end_mask': None, 'shrink_axis_mask': 4}, + {'shape': [12, 2, 2, 5], 'dtype': np.float32, 'strides': None, 'begin': [0, 0, 0, 0], 'end': [12, 2, 2, 5], + 'begin_mask': None, 'end_mask': None, 'shrink_axis_mask': None}, + {'shape': [12, 2, 2, 5], 'dtype': np.float32, 'strides': None, 'begin': [1, 0, 1, 0], 'end': [8, 2, 2, 3], + 'begin_mask': 8, 'end_mask': 3, 'shrink_axis_mask': 4}, + {'shape': [12, 2, 2, 5], 'dtype': np.int64, 'strides': [1], 'begin': [0], 'end': [1], + 'begin_mask': 8, 'end_mask': 3, 'shrink_axis_mask': None}, + {'shape': [12, 2, 2, 5], 'dtype': np.bool, 'strides': [1], 'begin': [0], 'end': [1], + 'begin_mask': 8, 'end_mask': 3, 'shrink_axis_mask': None}, +] + + +class TestTFLiteStridedSliceLayerTest(TFLiteLayerTest): + inputs = ["Input", "Begin", "End"] + outputs = ["StridedSlice"] + allowed_ops = ['STRIDED_SLICE'] + + def _prepare_input(self, inputs_dict, generator=None): + if self.input_dtype == np.bool: + inputs_dict['Input'] = np.random.choice([True, False], size=inputs_dict['Input']) + else: + inputs_dict['Input'] = np.random.randint(-255, 255, inputs_dict['Input']).astype(self.input_dtype) + inputs_dict['Begin'] = np.array(self.begin).astype(np.int32) + inputs_dict['End'] = np.array(self.end).astype(np.int32) + if self.strides: + inputs_dict["Strides"] = np.array(self.strides).astype(np.int32) + + return inputs_dict + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'dtype', 'strides', 'begin', + 'end', 'begin_mask', 'end_mask', 'shrink_axis_mask'})) == 8, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + self.input_dtype = params['dtype'] + self.begin = params['begin'] + self.end = params['end'] + self.strides = params['strides'] + if "Strides" in self.inputs: + self.inputs.pop(-1) + tf.compat.v1.reset_default_graph() + + with tf.compat.v1.Session() as sess: + placeholder = tf.compat.v1.placeholder(params['dtype'], params['shape'], self.inputs[0]) + begin = tf.compat.v1.placeholder(tf.int32, [len(params['begin'])], self.inputs[1]) + end = tf.compat.v1.placeholder(tf.int32, [len(params['end'])], self.inputs[2]) + strides = None + if params['strides']: + name = "Strides" + self.inputs.append(name) + strides = tf.compat.v1.placeholder(tf.int32, [len(params['end'])], name) + + tf.strided_slice(placeholder, begin, end, strides, + begin_mask=params['begin_mask'], end_mask=params['end_mask'], + shrink_axis_mask=params['shrink_axis_mask'], name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_strided_slice(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_Tile.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Tile.py new file mode 100644 index 00000000000..1e1edd934ba --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Tile.py @@ -0,0 +1,32 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [2], 'multiples': [2]}, + {'shape': [2, 3], 'multiples': [1, 2]}, + {'shape': [2, 3, 1], 'multiples': [5, 1, 3]}, +] + + +class TestTFLiteTileLayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["Tile"] + allowed_ops = ['TILE'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'multiples'})) == 2, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + + with tf.compat.v1.Session() as sess: + placeholder = tf.compat.v1.placeholder(tf.float32, params['shape'], self.inputs[0]) + tf.tile(placeholder, params['multiples'], name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_tile(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_TopKV2.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_TopKV2.py new file mode 100644 index 00000000000..ef9539b623b --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_TopKV2.py @@ -0,0 +1,33 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [2], 'k': 2, 'sorted': True}, + {'shape': [2, 3], 'k': 1, 'sorted': False}, + {'shape': [2, 3, 5], 'k': 2, 'sorted': True}, + {'shape': [2, 3, 5, 10], 'k': 9, 'sorted': False}, +] + + +class TestTFLiteTopKV2LayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["TopKV2"] + allowed_ops = ['TOPK_V2'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'k', 'sorted'})) == 3, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + + with tf.compat.v1.Session() as sess: + placeholder = tf.compat.v1.placeholder(tf.float32, params['shape'], self.inputs[0]) + tf.raw_ops.TopKV2(input=placeholder, k=params['k'], sorted=params['sorted'], name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_topk_v2(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_Transpose.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Transpose.py new file mode 100644 index 00000000000..25a4575969d --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Transpose.py @@ -0,0 +1,32 @@ +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +test_params = [ + {'shape': [2, 3], 'perm': [1, 0], 'conjugate': False}, + {'shape': [2, 3, 5], 'perm': [2, 0, 1], 'conjugate': True}, + {'shape': [2, 3, 5, 10], 'perm': [1, 2, 3, 0], 'conjugate': False}, +] + + +class TestTFLiteTransposeLayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["Transpose"] + allowed_ops = ['TRANSPOSE'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'perm', 'conjugate'})) == 3, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + + with tf.compat.v1.Session() as sess: + placeholder = tf.compat.v1.placeholder(tf.float32, params['shape'], self.inputs[0]) + tf.transpose(placeholder, params['perm'], params['conjugate'], name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_transpose(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_TransposeConv.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_TransposeConv.py new file mode 100644 index 00000000000..a56976cef99 --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_TransposeConv.py @@ -0,0 +1,45 @@ +import numpy as np +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +np.random.seed(42) + +test_params = [ + {'shape': [1, 3, 4, 1], 'ksize': [1, 1, 1, 1], 'output_shape': [1, 3, 4, 1], 'strides': [1, 1, 1, 1], + 'padding': 'SAME', 'data_format': 'NHWC', 'dilations': [1, 1, 1, 1]}, + {'shape': [1, 4, 4, 1], 'ksize': [1, 1, 1, 1], 'output_shape': [1, 4, 4, 1], 'strides': [1, 1], 'padding': 'SAME', + 'data_format': 'NHWC', 'dilations': [1, 2, 2, 1]}, + # + {'shape': [1, 22, 22, 3], 'ksize': [1, 1, 6, 3], 'output_shape': [1, 22, 22, 6], 'strides': [1, 1], + 'padding': 'VALID', 'data_format': 'NHWC', 'dilations': [1, 1, 1, 1]}, + {'shape': [1, 22, 22, 3], 'ksize': [3, 3, 3, 3], 'output_shape': [1, 24, 24, 3], 'strides': [1, 1], + 'padding': 'VALID', 'data_format': 'NHWC', 'dilations': [1, 1, 1, 1]}, +] + + +class TestTFLiteTransposeConvLayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["TransposeConv"] + allowed_ops = ['TRANSPOSE_CONV'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'ksize', 'strides', + 'padding', 'data_format', 'dilations', 'output_shape'})) == 7, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + placeholder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], + name=self.inputs[0]) + filter_input = tf.constant(np.random.randint(-1, 1, size=(params['ksize'])), dtype=tf.float32) + tf.nn.conv2d_transpose(placeholder, filter_input, params['output_shape'], params["strides"], + params["padding"], + params["data_format"], name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_transpose_conv(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_Unary.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Unary.py index b782202d112..ac45dc4283d 100644 --- a/tests/layer_tests/tensorflow_lite_tests/test_tfl_Unary.py +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Unary.py @@ -1,17 +1,16 @@ # Copyright (C) 2018-2023 Intel Corporation # SPDX-License-Identifier: Apache-2.0 -import itertools from functools import partial import numpy as np import pytest import tensorflow as tf + from common.tflite_layer_test_class import TFLiteLayerTest -from common.utils.tflite_utils import data_generators +from common.utils.tflite_utils import parametrize_tests np.random.seed(42) - test_ops = [ {'op_name': 'ABS', 'op_func': tf.math.abs}, {'op_name': 'CAST', 'op_func': partial(tf.cast, dtype=tf.int32)}, @@ -27,6 +26,7 @@ test_ops = [ {'op_name': 'LOGISTIC', 'op_func': tf.math.sigmoid}, {'op_name': 'NEG', 'op_func': tf.math.negative}, {'op_name': 'RELU6', 'op_func': tf.nn.relu6}, + {'op_name': 'RELU', 'op_func': tf.nn.relu}, {'op_name': 'ROUND', 'op_func': tf.math.round}, {'op_name': 'RSQRT', 'op_func': tf.math.rsqrt, 'kwargs_to_prepare_input': 'positive'}, {'op_name': 'SIN', 'op_func': tf.math.sin}, @@ -51,21 +51,13 @@ test_params = [ {'shape': [2, 10]} ] -test_data = list(itertools.product(test_ops, test_params)) -for i, (parameters, shapes) in enumerate(test_data): - parameters.update(shapes) - test_data[i] = parameters.copy() +test_data = parametrize_tests(test_ops, test_params) class TestTFLiteUnaryLayerTest(TFLiteLayerTest): inputs = ["Input"] outputs = ["UnaryOperation"] - def _prepare_input(self, inputs_dict, generator=None): - if generator is None: - return super()._prepare_input(inputs_dict) - return data_generators[generator](inputs_dict) - def make_model(self, params): assert len(set(params.keys()).intersection({'op_name', 'op_func', 'shape'})) == 3, \ 'Unexpected parameters for test: ' + ','.join(params.keys()) @@ -73,8 +65,8 @@ class TestTFLiteUnaryLayerTest(TFLiteLayerTest): tf.compat.v1.reset_default_graph() with tf.compat.v1.Session() as sess: place_holder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], - name=TestTFLiteUnaryLayerTest.inputs[0]) - params['op_func'](place_holder, name=TestTFLiteUnaryLayerTest.outputs[0]) + name=self.inputs[0]) + params['op_func'](place_holder, name=self.outputs[0]) net = sess.graph_def return net diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_Unique.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Unique.py new file mode 100644 index 00000000000..6c1adef7352 --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Unique.py @@ -0,0 +1,37 @@ +# Copyright (C) 2018-2023 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +np.random.seed(42) + +test_params = [ + {'shape': [15]}, + {'shape': [1]} +] + + +class TestTFLiteUniqueLayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["Unqiue"] + allowed_ops = ['UNIQUE'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape'})) == 1, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + placeholder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], + name=self.inputs[0]) + tf.unique(placeholder, name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_unique(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params) diff --git a/tests/layer_tests/tensorflow_lite_tests/test_tfl_Unpack.py b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Unpack.py new file mode 100644 index 00000000000..29838fc6ca2 --- /dev/null +++ b/tests/layer_tests/tensorflow_lite_tests/test_tfl_Unpack.py @@ -0,0 +1,41 @@ +# Copyright (C) 2018-2023 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np +import pytest +import tensorflow as tf + +from common.tflite_layer_test_class import TFLiteLayerTest + +np.random.seed(42) + +test_params = [ + {'shape': [3, 4, 3], 'axis': 0}, + {'shape': [3, 4, 3], 'axis': -1}, + {'shape': [3, 4, 3, 5], 'axis': -2}, + {'shape': [3, 4, 3, 5], 'axis': 2}, + {'shape': [1], 'axis': -1}, + {'shape': [1], 'axis': 0} +] + + +class TestTFLiteUnpackLayerTest(TFLiteLayerTest): + inputs = ["Input"] + outputs = ["Unpack"] + allowed_ops = ['UNPACK'] + + def make_model(self, params): + assert len(set(params.keys()).intersection({'shape', 'axis'})) == 2, \ + 'Unexpected parameters for test: ' + ','.join(params.keys()) + tf.compat.v1.reset_default_graph() + with tf.compat.v1.Session() as sess: + place_holder = tf.compat.v1.placeholder(params.get('dtype', tf.float32), params['shape'], + name=self.inputs[0]) + tf.unstack(place_holder, axis=params['axis'], name=self.outputs[0]) + net = sess.graph_def + return net + + @pytest.mark.parametrize("params", test_params) + @pytest.mark.nightly + def test_unpack(self, params, ie_device, precision, temp_dir): + self._test(ie_device, precision, temp_dir, params)