From 81fdb8a86cb4e1361f7942c0a3231fc566ec3389 Mon Sep 17 00:00:00 2001 From: Mikhail Nosov Date: Thu, 29 Jul 2021 13:09:51 +0300 Subject: [PATCH] [MO] Add support to moc_frontend of ":" as delimiter for --input and --output (#6543) * [MO] Add support to moc_frontend of ":" as delimiter for --input Additions: Changed default logic for 'Place::get_in(out)put_port' to return nullptr Changed default logic for 'InputModel::get_place_by_tensor(operation)_name' to return nullptr * Corrected comments in code * Missing empty line * Clang format fixes * Fix review comments * Updated test to verify review comments fixes * Update unit tests after rebase * Apply review comments --- model-optimizer/mo/front/extractor.py | 18 +- model-optimizer/mo/moc_frontend/extractor.py | 62 ++++- .../unit_tests/mo/frontend_ngraph_test.py | 9 + .../moc_frontend/moc_extractor_test_actual.py | 246 ++++++++++++++++++ .../mock_mo_frontend.cpp | 5 + .../mock_mo_frontend.hpp | 113 +++++++- .../mock_mo_python_api/mock_mo_python_api.cpp | 11 + .../include/frontend_manager/input_model.hpp | 11 +- .../include/frontend_manager/place.hpp | 16 +- .../frontend_manager/src/frontend_manager.cpp | 2 +- .../mock_py_frontend.hpp | 2 +- 11 files changed, 457 insertions(+), 38 deletions(-) create mode 100644 model-optimizer/unit_tests/mo/moc_frontend/moc_extractor_test_actual.py diff --git a/model-optimizer/mo/front/extractor.py b/model-optimizer/mo/front/extractor.py index a0376a6328ce9b..139dc6503eb680 100644 --- a/model-optimizer/mo/front/extractor.py +++ b/model-optimizer/mo/front/extractor.py @@ -451,6 +451,17 @@ def extract_node_attrs(graph: Graph, extractor: callable): return graph +def raise_no_node(node_name: str): + raise Error('No node with name {}'.format(node_name)) + + +def raise_node_name_collision(node_name: str, found_nodes: list): + raise Error('Name collision was found, there are several nodes for mask "{}": {}. ' + 'If your intention was to specify port for node, please instead specify node names connected to ' + 'this port. If your intention was to specify the node name, please add port to the node ' + 'name'.format(node_name, found_nodes)) + + def get_node_id_with_ports(graph: Graph, node_name: str, skip_if_no_port=True): """ Extracts port and node ID out of user provided name @@ -483,12 +494,9 @@ def get_node_id_with_ports(graph: Graph, node_name: str, skip_if_no_port=True): found_names.append((in_port, out_port, name)) if len(found_names) == 0: - raise Error('No node with name {}'.format(node_name)) + raise_no_node(node_name) if len(found_names) > 1: - raise Error('Name collision was found, there are several nodes for mask "{}": {}. ' - 'If your intention was to specify port for node, please instead specify node names connected to ' - 'this port. If your intention was to specify the node name, please add port to the node ' - 'name'.format(node_name, [name for _, _, name in found_names])) + raise_node_name_collision(node_name, [name for _, _, name in found_names]) in_port, out_port, name = found_names[0] node_id = graph.get_node_id_by_name(name) if in_port is not None: diff --git a/model-optimizer/mo/moc_frontend/extractor.py b/model-optimizer/mo/moc_frontend/extractor.py index 95f463bb8fb04f..b5ddd83b1fdef9 100644 --- a/model-optimizer/mo/moc_frontend/extractor.py +++ b/model-optimizer/mo/moc_frontend/extractor.py @@ -1,35 +1,75 @@ # Copyright (C) 2018-2021 Intel Corporation # SPDX-License-Identifier: Apache-2.0 -import logging as log import re -from collections import defaultdict -from copy import copy - -import numpy as np +from mo.front.extractor import raise_no_node, raise_node_name_collision from mo.utils.error import Error from ngraph.frontend import InputModel # pylint: disable=no-name-in-module,import-error +import numpy as np + def decode_name_with_port(input_model: InputModel, node_name: str): """ Decode name with optional port specification w/o traversing all the nodes in the graph - TODO: in future node_name can specify input/output port groups and indices (58562) + TODO: in future node_name can specify input/output port groups as well as indices (58562) :param input_model: Input Model :param node_name: user provided node name :return: decoded place in the graph """ - # Check exact match with one of the names in the graph first + found_nodes = [] + found_node_names = [] + node = input_model.get_place_by_tensor_name(node_name) if node: - return node + found_node_names.append('Tensor:' + node_name) + found_nodes.append(node) + + node = input_model.get_place_by_operation_name(node_name) + if node: + found_node_names.append('Operation:' + node_name) + found_nodes.append(node) + + regexp_post = r'(.+):(\d+)' + match_post = re.search(regexp_post, node_name) + if match_post: + node_post = input_model.get_place_by_operation_name(match_post.group(1)) + if node_post: + node_post = node_post.get_output_port( + outputPortIndex=int(match_post.group(2))) + if node_post: + found_node_names.append(match_post.group(1)) + found_nodes.append(node_post) + + regexp_pre = r'(\d+):(.+)' + match_pre = re.search(regexp_pre, node_name) + if match_pre: + node_pre = input_model.get_place_by_operation_name(match_pre.group(2)) + if node_pre: + node_pre = node_pre.get_input_port( + inputPortIndex=int(match_pre.group(1))) + if node_pre: + found_node_names.append(match_pre.group(2)) + found_nodes.append(node_pre) + + if len(found_nodes) == 0: + raise_no_node(node_name) + + # Check that there is no collision, all found places shall point to same data + if not all([n.is_equal_data(found_nodes[0]) for n in found_nodes]): + raise_node_name_collision(node_name, found_node_names) + + # TODO: ONNX specific (59408) + # To comply with legacy behavior, for ONNX-only there shall be considered additional 2 possibilities + # 1) "abc:1" - get_place_by_tensor_name("abc").get_producing_operation().get_output_port(1) + # 2) "1:abc" - get_place_by_tensor_name("abc").get_producing_operation().get_input_port(1) + # This logic is not going to work with other frontends # TODO: Add support for input/output group name and port index here (58562) - # Legacy frontends use format "number:name:number" to specify input and output port indices - # For new frontends this logic shall be extended to additionally support input and output group names - raise Error('There is no node with name {}'.format(node_name)) + # For new frontends logic shall be extended to additionally support input and output group names + return found_nodes[0] def fe_input_user_data_repack(input_model: InputModel, input_user_shapes: [None, list, dict, np.ndarray], diff --git a/model-optimizer/unit_tests/mo/frontend_ngraph_test.py b/model-optimizer/unit_tests/mo/frontend_ngraph_test.py index aaf24d14b92ff8..f440284b8f926a 100644 --- a/model-optimizer/unit_tests/mo/frontend_ngraph_test.py +++ b/model-optimizer/unit_tests/mo/frontend_ngraph_test.py @@ -34,6 +34,15 @@ def test_frontends(): assert not status.returncode +def test_moc_extractor(): + setup_env() + args = [sys.executable, '-m', 'pytest', + os.path.join(os.path.dirname(__file__), 'moc_frontend/moc_extractor_test_actual.py'), '-s'] + + status = subprocess.run(args, env=os.environ) + assert not status.returncode + + def test_main_test(): setup_env() args = [sys.executable, '-m', 'pytest', diff --git a/model-optimizer/unit_tests/mo/moc_frontend/moc_extractor_test_actual.py b/model-optimizer/unit_tests/mo/moc_frontend/moc_extractor_test_actual.py new file mode 100644 index 00000000000000..17ac755c4d17cd --- /dev/null +++ b/model-optimizer/unit_tests/mo/moc_frontend/moc_extractor_test_actual.py @@ -0,0 +1,246 @@ +# Copyright (C) 2018-2021 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import unittest + +from mo.moc_frontend.extractor import decode_name_with_port +from mo.utils.error import Error + +import pytest + + +mock_available = True + +try: + # pylint: disable=no-name-in-module,import-error + from mock_mo_python_api import get_model_statistic, get_place_statistic, \ + clear_frontend_statistic, clear_model_statistic, clear_place_statistic, \ + clear_setup, set_equal_data, set_max_port_counts + + # pylint: disable=no-name-in-module,import-error + from ngraph.frontend import FrontEndManager + +except Exception: + print("No mock frontend API available," + "ensure to use -DENABLE_TESTS=ON option when running these tests") + mock_available = False + +# FrontEndManager shall be initialized and destroyed after all tests finished +# This is because destroy of FrontEndManager will unload all plugins, +# no objects shall exist after this +if mock_available: + fem = FrontEndManager() + +mock_needed = pytest.mark.skipif(not mock_available, + reason="mock MO fe is not available") + + +class TestMainFrontend(unittest.TestCase): + def setUp(self): + clear_frontend_statistic() + clear_model_statistic() + clear_place_statistic() + clear_setup() + set_max_port_counts(10, 10) + self.fe = fem.load_by_framework('mock_mo_ngraph_frontend') + self.model = self.fe.load('abc.bin') + + # Mock model has 'tensor' tensor place + @mock_needed + def test_decode_name_with_port_tensor(self): + node = decode_name_with_port(self.model, "tensor") + model_stat = get_model_statistic() + + assert model_stat.get_place_by_tensor_name == 1 + assert model_stat.get_place_by_operation_name == 1 + assert node + + # Mock model has 'operation' operation place + @mock_needed + def test_decode_name_with_port_op(self): + node = decode_name_with_port(self.model, "operation") + model_stat = get_model_statistic() + + assert model_stat.get_place_by_tensor_name == 1 + assert model_stat.get_place_by_operation_name == 1 + assert node + + # pylint: disable=wrong-spelling-in-comment + # Mock model doesn't have 'mocknoname' place + @mock_needed + def test_decode_name_with_port_noname(self): + with self.assertRaisesRegex(Error, 'No\\ node\\ with\\ name.*mocknoname*'): + decode_name_with_port(self.model, 'mocknoname') + model_stat = get_model_statistic() + assert model_stat.get_place_by_tensor_name == 1 + assert model_stat.get_place_by_operation_name == 1 + + # Mock model has both tensor and operation with same name and non-equal data + # Collision is expected + @mock_needed + def test_decode_name_with_port_collision_op_tensor(self): + with self.assertRaisesRegex(Error, 'Name\\ collision.*tensorAndOp*'): + decode_name_with_port(self.model, 'tensorAndOp') + model_stat = get_model_statistic() + place_stat = get_place_statistic() + + assert model_stat.get_place_by_tensor_name == 1 + assert model_stat.get_place_by_operation_name == 1 + assert place_stat.is_equal_data > 0 + + # Mock model has 'operation' and output port up to 10 + @mock_needed + def test_decode_name_with_port_delim_op_out(self): + node = decode_name_with_port(self.model, 'operation:7') + model_stat = get_model_statistic() + place_stat = get_place_statistic() + + assert model_stat.get_place_by_tensor_name == 1 + assert model_stat.get_place_by_operation_name == 2 + assert place_stat.get_output_port == 1 + assert place_stat.lastArgInt == 7 + assert node + + # Mock model has 'operation' and input port up to 10 + @mock_needed + def test_decode_name_with_port_delim_op_in(self): + node = decode_name_with_port(self.model, '7:operation') + model_stat = get_model_statistic() + place_stat = get_place_statistic() + + assert model_stat.get_place_by_tensor_name == 1 + assert model_stat.get_place_by_operation_name == 2 + assert place_stat.get_input_port == 1 + assert place_stat.lastArgInt == 7 + assert node + + # Mock model has 'operation' and 'operation:0' op places, collision is expected + @mock_needed + def test_decode_name_with_port_delim_op_collision_out(self): + with self.assertRaisesRegex(Error, 'Name\\ collision(?!.*Tensor.*).*operation\\:0*'): + decode_name_with_port(self.model, 'operation:0') + model_stat = get_model_statistic() + place_stat = get_place_statistic() + + assert model_stat.get_place_by_tensor_name == 1 + assert model_stat.get_place_by_operation_name == 2 + assert place_stat.is_equal_data > 0 + assert place_stat.get_output_port == 1 + assert place_stat.lastArgInt == 0 + + # Mock model has 'operation' and '0:operation' op places, collision is expected + @mock_needed + def test_decode_name_with_port_delim_op_collision_in(self): + with self.assertRaisesRegex(Error, 'Name\\ collision(?!.*Tensor.*).*0\\:operation*'): + decode_name_with_port(self.model, '0:operation') + model_stat = get_model_statistic() + place_stat = get_place_statistic() + + assert model_stat.get_place_by_tensor_name == 1 + assert model_stat.get_place_by_operation_name == 2 + assert place_stat.is_equal_data > 0 + assert place_stat.get_input_port == 1 + assert place_stat.lastArgInt == 0 + + # Mock model has 'tensor' and 'tensor:0' tensor places, no collision is expected + @mock_needed + def test_decode_name_with_port_delim_tensor_no_collision_out(self): + node = decode_name_with_port(self.model, 'tensor:0') + model_stat = get_model_statistic() + place_stat = get_place_statistic() + + assert model_stat.get_place_by_tensor_name == 1 + assert model_stat.get_place_by_operation_name == 2 + assert place_stat.get_output_port == 0 + assert node + + # Mock model has 'tensor' and '0:tensor' tensor places, no collision is expected + @mock_needed + def test_decode_name_with_port_delim_tensor_no_collision_in(self): + node = decode_name_with_port(self.model, '0:tensor') + model_stat = get_model_statistic() + place_stat = get_place_statistic() + + assert model_stat.get_place_by_tensor_name == 1 + assert model_stat.get_place_by_operation_name == 2 + assert place_stat.get_input_port == 0 + assert node + + # Mock model doesn't have such '1234:operation' or output port=1234 for 'operation' + @mock_needed + def test_decode_name_with_port_delim_no_port_out(self): + with self.assertRaisesRegex(Error, 'No\\ node\\ with\\ name.*operation\\:1234*'): + decode_name_with_port(self.model, 'operation:1234') + model_stat = get_model_statistic() + place_stat = get_place_statistic() + + assert model_stat.get_place_by_tensor_name == 1 + assert model_stat.get_place_by_operation_name == 2 + assert place_stat.get_output_port == 1 + assert place_stat.lastArgInt == 1234 + + # Mock model doesn't have such '1234:operation' or input port=1234 for 'operation' + @mock_needed + def test_decode_name_with_port_delim_no_port_in(self): + with self.assertRaisesRegex(Error, 'No\\ node\\ with\\ name.*1234\\:operation*'): + decode_name_with_port(self.model, '1234:operation') + model_stat = get_model_statistic() + place_stat = get_place_statistic() + + assert model_stat.get_place_by_tensor_name == 1 + assert model_stat.get_place_by_operation_name == 2 + assert place_stat.get_input_port == 1 + assert place_stat.lastArgInt == 1234 + + # Mock model has tensor with name 'conv2d:0' and operation 'conv2d' with output port = 1 + # It is setup to return 'is_equal_data=True' for these tensor and port + # So no collision is expected + @mock_needed + def test_decode_name_with_port_delim_equal_data_out(self): + set_equal_data('conv2d', 'conv2d') + node = decode_name_with_port(self.model, 'conv2d:0') + model_stat = get_model_statistic() + place_stat = get_place_statistic() + + assert model_stat.get_place_by_tensor_name == 1 + assert model_stat.get_place_by_operation_name == 2 + assert place_stat.get_output_port == 1 + assert place_stat.is_equal_data > 0 + assert node + + # Mock model has tensor with name '0:conv2d' and operation 'conv2d' with input port = 1 + # It is setup to return 'is_equal_data=True' for these tensor and port + # So no collision is expected + @mock_needed + def test_decode_name_with_port_delim_equal_data_in(self): + set_equal_data('conv2d', 'conv2d') + node = decode_name_with_port(self.model, '0:conv2d') + model_stat = get_model_statistic() + place_stat = get_place_statistic() + + assert model_stat.get_place_by_tensor_name == 1 + assert model_stat.get_place_by_operation_name == 2 + assert place_stat.get_input_port == 1 + assert place_stat.is_equal_data > 0 + assert node + + # Stress case: Mock model has: + # Tensor '8:9' + # Operation '8:9' + # Operation '8' with output port = 9 + # Operation '9' with input port = 8 + # All places point to same data - no collision is expected + @mock_needed + def test_decode_name_with_port_delim_all_same_data(self): + set_equal_data('8', '9') + node = decode_name_with_port(self.model, '8:9') + model_stat = get_model_statistic() + place_stat = get_place_statistic() + + assert model_stat.get_place_by_tensor_name == 1 + assert model_stat.get_place_by_operation_name == 3 + assert place_stat.get_input_port == 1 + assert place_stat.get_output_port == 1 + # At least 3 comparisons of places are expected + assert place_stat.is_equal_data > 2 + assert node diff --git a/model-optimizer/unit_tests/mock_mo_frontend/mock_mo_ngraph_frontend/mock_mo_frontend.cpp b/model-optimizer/unit_tests/mock_mo_frontend/mock_mo_ngraph_frontend/mock_mo_frontend.cpp index 9ddbba38040770..17c647e35b5801 100644 --- a/model-optimizer/unit_tests/mock_mo_frontend/mock_mo_ngraph_frontend/mock_mo_frontend.cpp +++ b/model-optimizer/unit_tests/mock_mo_frontend/mock_mo_ngraph_frontend/mock_mo_frontend.cpp @@ -14,6 +14,11 @@ FeStat FrontEndMockPy::m_stat = {}; ModelStat InputModelMockPy::m_stat = {}; PlaceStat PlaceMockPy::m_stat = {}; +std::string MockSetup::m_equal_data_node1 = {}; +std::string MockSetup::m_equal_data_node2 = {}; +int MockSetup::m_max_input_port_index = 0; +int MockSetup::m_max_output_port_index = 0; + PartialShape InputModelMockPy::m_returnShape = {}; extern "C" MOCK_API FrontEndVersion GetAPIVersion() diff --git a/model-optimizer/unit_tests/mock_mo_frontend/mock_mo_ngraph_frontend/mock_mo_frontend.hpp b/model-optimizer/unit_tests/mock_mo_frontend/mock_mo_ngraph_frontend/mock_mo_frontend.hpp index e6b91764a0d169..eb8182132f95c1 100644 --- a/model-optimizer/unit_tests/mock_mo_frontend/mock_mo_ngraph_frontend/mock_mo_frontend.hpp +++ b/model-optimizer/unit_tests/mock_mo_frontend/mock_mo_ngraph_frontend/mock_mo_frontend.hpp @@ -21,6 +21,35 @@ using namespace ngraph; using namespace ngraph::frontend; //////////////////////////////// +/// \brief This structure holds number static setup values +/// It will be used by Python unit tests to setup particular mock behavior +struct MOCK_API MockSetup +{ + static std::string m_equal_data_node1; + static std::string m_equal_data_node2; + static int m_max_input_port_index; + static int m_max_output_port_index; + + static void clear_setup() + { + m_equal_data_node1 = {}; + m_equal_data_node2 = {}; + m_max_input_port_index = 0; + m_max_output_port_index = 0; + } + + static void set_equal_data(const std::string& node1, const std::string& node2) + { + m_equal_data_node1 = node1; + m_equal_data_node2 = node2; + } + + static void set_max_port_counts(int max_input, int max_output) + { + m_max_input_port_index = max_input; + m_max_output_port_index = max_output; + } +}; /// \brief This structure holds number of calls of particular methods of Place objects /// It will be used by Python unit tests to verify that appropriate API @@ -33,6 +62,7 @@ struct MOCK_API PlaceStat int m_is_input = 0; int m_is_output = 0; int m_is_equal = 0; + int m_is_equal_data = 0; // Arguments tracking std::string m_lastArgString; @@ -46,6 +76,7 @@ struct MOCK_API PlaceStat int is_input() const { return m_is_input; } int is_output() const { return m_is_output; } int is_equal() const { return m_is_equal; } + int is_equal_data() const { return m_is_equal_data; } // Arguments getters std::string get_lastArgString() const { return m_lastArgString; } @@ -60,10 +91,14 @@ class MOCK_API PlaceMockPy : public Place { static PlaceStat m_stat; std::string m_name; + bool m_is_op = false; + int m_portIndex = -1; public: - PlaceMockPy(const std::string& name = {}) + PlaceMockPy(const std::string& name = {}, bool is_op = false, int portIndex = -1) : m_name(name) + , m_is_op(is_op) + , m_portIndex(portIndex) { } @@ -84,7 +119,11 @@ class MOCK_API PlaceMockPy : public Place { m_stat.m_get_input_port++; m_stat.m_lastArgInt = inputPortIndex; - return std::make_shared(); + if (inputPortIndex < MockSetup::m_max_input_port_index) + { + return std::make_shared(m_name, false, inputPortIndex); + } + return nullptr; } Place::Ptr get_input_port(const std::string& inputName) const override @@ -114,7 +153,11 @@ class MOCK_API PlaceMockPy : public Place { m_stat.m_get_output_port++; m_stat.m_lastArgInt = outputPortIndex; - return std::make_shared(); + if (outputPortIndex < MockSetup::m_max_output_port_index) + { + return std::make_shared(m_name, false, outputPortIndex); + } + return nullptr; } Place::Ptr get_output_port(const std::string& outputName) const override @@ -149,7 +192,27 @@ class MOCK_API PlaceMockPy : public Place { m_stat.m_is_equal++; m_stat.m_lastArgPlace = another; - return m_name == another->get_names().at(0); + std::shared_ptr mock = std::dynamic_pointer_cast(another); + return m_name == mock->m_name && m_is_op == mock->m_is_op && + m_portIndex == mock->m_portIndex; + } + + bool is_equal_data(Ptr another) const override + { + m_stat.m_is_equal_data++; + m_stat.m_lastArgPlace = another; + std::shared_ptr mock = std::dynamic_pointer_cast(another); + if (!MockSetup::m_equal_data_node1.empty() && !MockSetup::m_equal_data_node2.empty()) + { + if ((mock->m_name.find(MockSetup::m_equal_data_node1) != std::string::npos || + mock->m_name.find(MockSetup::m_equal_data_node2) != std::string::npos) && + (m_name.find(MockSetup::m_equal_data_node1) != std::string::npos || + m_name.find(MockSetup::m_equal_data_node2) != std::string::npos)) + { + return true; + } + } + return mock->m_is_op == m_is_op; } //---------------Stat-------------------- @@ -167,6 +230,7 @@ struct MOCK_API ModelStat int m_get_inputs = 0; int m_get_outputs = 0; int m_get_place_by_tensor_name = 0; + int m_get_place_by_operation_name = 0; int m_set_partial_shape = 0; int m_get_partial_shape = 0; int m_set_element_type = 0; @@ -190,6 +254,7 @@ struct MOCK_API ModelStat int extract_subgraph() const { return m_extract_subgraph; } int override_all_inputs() const { return m_override_all_inputs; } int override_all_outputs() const { return m_override_all_outputs; } + int get_place_by_operation_name() const { return m_get_place_by_operation_name; } int get_place_by_tensor_name() const { return m_get_place_by_tensor_name; } int set_partial_shape() const { return m_set_partial_shape; } int get_partial_shape() const { return m_get_partial_shape; } @@ -208,12 +273,31 @@ struct MOCK_API ModelStat /// \brief Mock implementation of InputModel /// Every call increments appropriate counters in statistic and stores argument values to statistics /// as well -/// ("mock_output1", "mock_output2") class MOCK_API InputModelMockPy : public InputModel { static ModelStat m_stat; static PartialShape m_returnShape; + std::set m_operations = { + "8", "9", "8:9", "operation", "operation:0", "0:operation", "tensorAndOp", "conv2d"}; + std::set m_tensors = {"8:9", + "tensor", + "tensor:0", + "0:tensor", + "tensorAndOp", + "conv2d:0", + "0:conv2d", + "mock_input1", + "mock_input2", + "newInput1", + "newIn1", + "newIn2", + "mock_output1", + "mock_output2", + "new_output2", + "newOut1", + "newOut2"}; + public: std::vector get_inputs() const override { @@ -229,11 +313,26 @@ class MOCK_API InputModelMockPy : public InputModel std::make_shared("mock_output2")}; } + Place::Ptr get_place_by_operation_name(const std::string& opName) const override + { + m_stat.m_get_place_by_operation_name++; + m_stat.m_lastArgString = opName; + if (m_operations.count(opName)) + { + return std::make_shared(opName, true); + } + return nullptr; + } + Place::Ptr get_place_by_tensor_name(const std::string& tensorName) const override { m_stat.m_get_place_by_tensor_name++; m_stat.m_lastArgString = tensorName; - return std::make_shared(tensorName); + if (m_tensors.count(tensorName)) + { + return std::make_shared(tensorName); + } + return nullptr; } void override_all_outputs(const std::vector& outputs) override @@ -319,7 +418,7 @@ class MOCK_API FrontEndMockPy : public FrontEnd static void clear_stat() { m_stat = {}; } -protected: +private: InputModel::Ptr load_impl(const std::vector>& params) const override { if (params.size() > 0 && is_type>(params[0])) diff --git a/model-optimizer/unit_tests/mock_mo_frontend/mock_mo_python_api/mock_mo_python_api.cpp b/model-optimizer/unit_tests/mock_mo_frontend/mock_mo_python_api/mock_mo_python_api.cpp index d5b7978932688f..d2d17042cfc5bd 100644 --- a/model-optimizer/unit_tests/mock_mo_frontend/mock_mo_python_api/mock_mo_python_api.cpp +++ b/model-optimizer/unit_tests/mock_mo_frontend/mock_mo_python_api/mock_mo_python_api.cpp @@ -21,6 +21,13 @@ static void register_mock_frontend_stat(py::module m) feStat.def_property_readonly("convert_model", &FeStat::convert_model); } +static void register_mock_setup(py::module m) +{ + m.def("clear_setup", &MockSetup::clear_setup); + m.def("set_equal_data", &MockSetup::set_equal_data); + m.def("set_max_port_counts", &MockSetup::set_max_port_counts); +} + static void register_mock_model_stat(py::module m) { m.def("get_model_statistic", &InputModelMockPy::get_stat); @@ -30,6 +37,8 @@ static void register_mock_model_stat(py::module m) py::class_ mdlStat(m, "ModelStat", py::dynamic_attr()); mdlStat.def_property_readonly("get_inputs", &ModelStat::get_inputs); mdlStat.def_property_readonly("get_outputs", &ModelStat::get_outputs); + mdlStat.def_property_readonly("get_place_by_operation_name", + &ModelStat::get_place_by_operation_name); mdlStat.def_property_readonly("get_place_by_tensor_name", &ModelStat::get_place_by_tensor_name); mdlStat.def_property_readonly("set_partial_shape", &ModelStat::set_partial_shape); @@ -66,12 +75,14 @@ static void register_mock_place_stat(py::module m) placeStat.def_property_readonly("is_input", &PlaceStat::is_input); placeStat.def_property_readonly("is_output", &PlaceStat::is_output); placeStat.def_property_readonly("is_equal", &PlaceStat::is_equal); + placeStat.def_property_readonly("is_equal_data", &PlaceStat::is_equal_data); } PYBIND11_MODULE(mock_mo_python_api, m) { m.doc() = "Mock frontend call counters for testing Pyngraph frontend bindings"; register_mock_frontend_stat(m); + register_mock_setup(m); register_mock_model_stat(m); register_mock_place_stat(m); } diff --git a/ngraph/frontend/frontend_manager/include/frontend_manager/input_model.hpp b/ngraph/frontend/frontend_manager/include/frontend_manager/input_model.hpp index 6ec3f6060fc4d9..4036532659e436 100644 --- a/ngraph/frontend/frontend_manager/include/frontend_manager/input_model.hpp +++ b/ngraph/frontend/frontend_manager/include/frontend_manager/input_model.hpp @@ -69,13 +69,14 @@ namespace ngraph /// \brief Returns a tensor place by a tensor name following framework conventions, or /// nullptr if a tensor with this name doesn't exist. /// \param tensor_name Name of tensor - /// \return Tensor place corresponding to specifed tensor name + /// \return Tensor place corresponding to specified tensor name or nullptr if not exists virtual Place::Ptr get_place_by_tensor_name(const std::string& tensor_name) const; /// \brief Returns an operation place by an operation name following framework - /// conventions, or nullptr if an operation with this name doesn't exist. \param - /// operation_name Name of operation \return Place representing operation - virtual Place::Ptr get_place_by_operation_name(const std::string& operation_name); + /// conventions, or nullptr if an operation with this name doesn't exist. + /// \param operation_name Name of operation + /// \return Place representing operation or nullptr if not exists + virtual Place::Ptr get_place_by_operation_name(const std::string& operation_name) const; /// \brief Returns an input port place by operation name and appropriate port index /// \param operation_name Name of operation @@ -88,7 +89,7 @@ namespace ngraph /// \brief Returns an output port place by operation name and appropriate port index /// \param operation_name Name of operation /// \param output_port_index Index of output port for this operation - /// \return Place representing output port of operation + /// \return Place representing output port of operation or nullptr if not exists virtual Place::Ptr get_place_by_operation_name_and_output_port(const std::string& operation_name, int output_port_index); diff --git a/ngraph/frontend/frontend_manager/include/frontend_manager/place.hpp b/ngraph/frontend/frontend_manager/include/frontend_manager/place.hpp index 5ffb80664c99c6..c03692b5220f26 100644 --- a/ngraph/frontend/frontend_manager/include/frontend_manager/place.hpp +++ b/ngraph/frontend/frontend_manager/include/frontend_manager/place.hpp @@ -232,14 +232,14 @@ namespace ngraph /// \brief For operation node returns reference to an input port; applicable if /// operation node has only one input port /// - /// \return Input port place + /// \return Input port place or nullptr if not exists virtual Ptr get_input_port() const; /// \brief For operation node returns reference to an input port with specified index /// /// \param input_port_index Input port index /// - /// \return Appropriate input port place + /// \return Appropriate input port place or nullptr if not exists virtual Ptr get_input_port(int input_port_index) const; /// \brief For operation node returns reference to an input port with specified name; @@ -247,7 +247,7 @@ namespace ngraph /// /// \param input_name Name of port group /// - /// \return Appropriate input port place + /// \return Appropriate input port place or nullptr if not exists virtual Ptr get_input_port(const std::string& input_name) const; /// \brief For operation node returns reference to an input port with specified name and @@ -257,20 +257,20 @@ namespace ngraph /// /// \param input_port_index Input port index in a group /// - /// \return Appropriate input port place + /// \return Appropriate input port place or nullptr if not exists virtual Ptr get_input_port(const std::string& input_name, int input_port_index) const; /// \brief For operation node returns reference to an output port; applicable for /// operations with only one output port /// - /// \return Appropriate output port place + /// \return Appropriate output port place or nullptr if not exists virtual Ptr get_output_port() const; /// \brief For operation node returns reference to an output port with specified index /// /// \param output_port_index Output port index /// - /// \return Appropriate output port place + /// \return Appropriate output port place or nullptr if not exists virtual Ptr get_output_port(int output_port_index) const; /// \brief For operation node returns reference to an output port with specified name; @@ -278,7 +278,7 @@ namespace ngraph /// /// \param output_name Name of output port group /// - /// \return Appropriate output port place + /// \return Appropriate output port place or nullptr if not exists virtual Ptr get_output_port(const std::string& output_name) const; /// \brief For operation node returns reference to an output port with specified name @@ -288,7 +288,7 @@ namespace ngraph /// /// \param output_port_index Output port index /// - /// \return Appropriate output port place + /// \return Appropriate output port place or nullptr if not exists virtual Ptr get_output_port(const std::string& output_name, int output_port_index) const; diff --git a/ngraph/frontend/frontend_manager/src/frontend_manager.cpp b/ngraph/frontend/frontend_manager/src/frontend_manager.cpp index f599d419c36c49..a37b56586df10a 100644 --- a/ngraph/frontend/frontend_manager/src/frontend_manager.cpp +++ b/ngraph/frontend/frontend_manager/src/frontend_manager.cpp @@ -183,7 +183,7 @@ Place::Ptr InputModel::get_place_by_tensor_name(const std::string& tensor_name) return nullptr; } -Place::Ptr InputModel::get_place_by_operation_name(const std::string& operation_name) +Place::Ptr InputModel::get_place_by_operation_name(const std::string& operation_name) const { return nullptr; } diff --git a/ngraph/python/tests/mock/mock_py_ngraph_frontend/mock_py_frontend.hpp b/ngraph/python/tests/mock/mock_py_ngraph_frontend/mock_py_frontend.hpp index d3e09583481769..abab82b6bb0abc 100644 --- a/ngraph/python/tests/mock/mock_py_ngraph_frontend/mock_py_frontend.hpp +++ b/ngraph/python/tests/mock/mock_py_ngraph_frontend/mock_py_frontend.hpp @@ -334,7 +334,7 @@ class MOCK_API InputModelMockPy : public InputModel return std::make_shared(); } - Place::Ptr get_place_by_operation_name(const std::string& operationName) override + Place::Ptr get_place_by_operation_name(const std::string& operationName) const override { m_stat.m_get_place_by_operation_name++; m_stat.m_lastArgString = operationName;