[PYTHON API] move frontend bindings to pyopenvino + move MO to use new Python API (#8301)

* move frontend folder to pyopenvino

* rename includes and add compile options

* include frontend to pyopenvino

* move __init__.py

* move tests

* remove mock from tests_compatibility

* rename import module

* Fix code style cpp

* refactor a few lines

* update few lines in mo

* Add pyopenvino to dependencies

* Fix mock

* update docstring

* Fix mo test

* remove module local

* fix code style

* update comment

* fix return type

* update docs

* fix code style

* fix building

* fix code style

* try to move MO to use new api

* Export more enum names from nrgaph

* [Python API] quick fix of packaging

* update tests

* fix setup.py

* small fix

* small fixes according to comments

* skip mo frontend tests

* update mo to new imports

* try to fix win wheel

* fix win wheel

* fix code style

Co-authored-by: Anastasia Kuporosova <anastasia.kuporosova@intel.com>
Co-authored-by: y <ilya.lavrenov@intel.com>

model-optimizer/CMakeLists.txt

@@ -4,7 +4,7 @@
 if(NOT ENABLE_PYTHON)
     message(WARNING "Please enable IE & nGraph Python API (ie_api and offline_transformations_api) targets to enable Model Optimizer target")
 else()
-    add_custom_target(model_optimizer DEPENDS ie_api offline_transformations_api ir_ov_frontend)
+    add_custom_target(model_optimizer DEPENDS ie_api offline_transformations_api ir_ov_frontend pyopenvino)
     if(ENABLE_TESTS)
         add_subdirectory(unit_tests/mock_mo_frontend/mock_mo_ov_frontend)
         add_dependencies(model_optimizer mock_mo_ov_frontend)

model-optimizer/mo/back/offline_transformations.py

@@ -9,65 +9,63 @@ from mo.utils.cli_parser import parse_transform
 
 def get_available_transformations():
     try:
-        from openvino.offline_transformations import ApplyLowLatencyTransformation, ApplyMakeStatefulTransformation # pylint: disable=import-error,no-name-in-module
+        from openvino.offline_transformations_pybind import apply_low_latency_transformation, apply_make_stateful_transformation # pylint: disable=import-error,no-name-in-module
         return {
-            'MakeStateful': ApplyMakeStatefulTransformation,
-            'LowLatency2': ApplyLowLatencyTransformation,
+            'MakeStateful': apply_make_stateful_transformation,
+            'LowLatency2': apply_low_latency_transformation,
         }
     except Exception as e:
         return {}
 
 
 # net should be openvino.inference_engine.IENetwork type, but IE Engine is still optional dependency
-def apply_user_transformations(net: object, transforms: list):
+def apply_user_transformations(func: object, transforms: list):
     available_transformations = get_available_transformations()
 
     for name, args in transforms:
         if name not in available_transformations.keys():
             raise Error("Transformation {} is not available.".format(name))
 
-        available_transformations[name](net, **args)
+        available_transformations[name](func, **args)
 
 
-def apply_moc_transformations(net: object):
-    from openvino.offline_transformations import ApplyMOCTransformations  # pylint: disable=import-error,no-name-in-module
-    ApplyMOCTransformations(net, False)
+def apply_moc_transformations(func: object):
+    from openvino.offline_transformations_pybind import apply_moc_transformations  # pylint: disable=import-error,no-name-in-module
+    apply_moc_transformations(func, False)
 
-def compress_model(net:object):
-    from openvino.offline_transformations import CompressModelTransformation  # pylint: disable=import-error,no-name-in-module
-    CompressModelTransformation(net)
+def compress_model(func: object):
+    from openvino.offline_transformations_pybind import compress_model_transformation  # pylint: disable=import-error,no-name-in-module
+    compress_model_transformation(func)
 
 def apply_offline_transformations(input_model: str, framework: str, transforms: list, compress_fp16=False):
     # This variable is only needed by GenerateMappingFile transformation
     # to produce correct mapping
     extract_names = framework in ['tf', 'mxnet', 'kaldi']
 
-    from openvino.offline_transformations import GenerateMappingFile, Serialize  # pylint: disable=import-error,no-name-in-module
-    from openvino.inference_engine import IENetwork  # pylint: disable=import-error,no-name-in-module
-    from ngraph.frontend import FrontEndManager, FrontEnd  # pylint: disable=no-name-in-module,import-error
-    from ngraph.impl import Function  # pylint: disable=no-name-in-module,import-error
+    from openvino.offline_transformations_pybind import generate_mapping_file, serialize  # pylint: disable=import-error,no-name-in-module
+    from openvino.frontend import FrontEndManager, FrontEnd  # pylint: disable=no-name-in-module,import-error
 
     fem = FrontEndManager()
 
     # We have to separate fe object lifetime from fem to
     # avoid segfault during object destruction. So fe must
     # be destructed before fem object explicitly.
-    def read_network(path_to_xml):
+    def read_model(path_to_xml):
         fe = fem.load_by_framework(framework="ir")
-        f = fe.convert(fe.load(path_to_xml))
-        return IENetwork(Function.to_capsule(f))
+        function = fe.convert(fe.load(path_to_xml))
+        return function
 
-    net = read_network(input_model + "_tmp.xml")
+    func = read_model(input_model + "_tmp.xml")
 
-    apply_user_transformations(net, transforms)
-    apply_moc_transformations(net)
+    apply_user_transformations(func, transforms)
+    apply_moc_transformations(func)
 
     if compress_fp16:
-        compress_model(net)
+        compress_model(func)
 
-    Serialize(net, str(input_model + ".xml").encode('utf-8'), (input_model + ".bin").encode('utf-8'))
+    serialize(func, str(input_model + ".xml").encode('utf-8'), (input_model + ".bin").encode('utf-8'))
     path_to_mapping = input_model + ".mapping"
-    GenerateMappingFile(net, path_to_mapping.encode('utf-8'), extract_names)
+    generate_mapping_file(func, path_to_mapping.encode('utf-8'), extract_names)
 
 
 if __name__ == "__main__":

model-optimizer/mo/main.py

@@ -45,7 +45,7 @@ from mo.utils.versions_checker import check_requirements  # pylint: disable=no-n
 from mo.utils.telemetry_utils import get_tid
 
 # pylint: disable=no-name-in-module,import-error
-from ngraph.frontend import FrontEndManager, TelemetryExtension
+from openvino.frontend import FrontEndManager, TelemetryExtension
 
 
 def replace_ext(name: str, old: str, new: str):

model-optimizer/mo/main_onnx.py

@@ -7,6 +7,6 @@ from mo.utils.cli_parser import get_onnx_cli_parser
 
 if __name__ == "__main__":
     from mo.main import main
-    from ngraph.frontend import FrontEndManager  # pylint: disable=no-name-in-module,import-error
+    from openvino.frontend import FrontEndManager  # pylint: disable=no-name-in-module,import-error
 
     sys.exit(main(get_onnx_cli_parser(), FrontEndManager(), 'onnx'))

model-optimizer/mo/main_paddle.py

@@ -5,7 +5,7 @@ import sys
 
 from mo.utils.cli_parser import get_all_cli_parser
 
-from ngraph.frontend import FrontEndManager  # pylint: disable=no-name-in-module,import-error
+from openvino.frontend import FrontEndManager  # pylint: disable=no-name-in-module,import-error
 
 
 if __name__ == "__main__":

model-optimizer/mo/moc_frontend/extractor.py

@@ -6,7 +6,7 @@ import re
 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
+from openvino.frontend import InputModel  # pylint: disable=no-name-in-module,import-error
 
 import numpy as np
 

model-optimizer/mo/moc_frontend/pipeline.py

@@ -8,9 +8,9 @@ from typing import List
 from mo.moc_frontend.extractor import fe_user_data_repack
 from mo.middle.passes.infer import validate_batch_in_shape
 
-from ngraph import Dimension, PartialShape        # pylint: disable=no-name-in-module,import-error
-from ngraph.frontend import FrontEnd, Place       # pylint: disable=no-name-in-module,import-error
-from ngraph.utils.types import get_element_type   # pylint: disable=no-name-in-module,import-error
+from openvino.runtime import Dimension, PartialShape        # pylint: disable=no-name-in-module,import-error
+from openvino.frontend import FrontEnd, Place       # pylint: disable=no-name-in-module,import-error
+from openvino.runtime.utils.types import get_element_type   # pylint: disable=no-name-in-module,import-error
 
 
 def moc_pipeline(argv: argparse.Namespace, moc_front_end: FrontEnd):

model-optimizer/mo/moc_frontend/serialize.py

@@ -7,24 +7,24 @@ from mo.pipeline.common import get_ir_version
 from mo.back.ie_ir_ver_2.emitter import append_ir_info
 from mo.utils.cli_parser import get_meta_info, parse_transform
 
-from ngraph import Function         # pylint: disable=no-name-in-module,import-error
-from ngraph import function_to_cnn  # pylint: disable=no-name-in-module,import-error
+from openvino.runtime import Function         # pylint: disable=no-name-in-module,import-error
 
 
 def moc_emit_ir(ngraph_function: Function, argv: argparse.Namespace):
     output_dir = argv.output_dir if argv.output_dir != '.' else os.getcwd()
 
-    network = function_to_cnn(ngraph_function)
     from mo.back.offline_transformations import apply_user_transformations, apply_moc_transformations
-    apply_user_transformations(network, parse_transform(argv.transform))
-    apply_moc_transformations(network)
+    apply_user_transformations(ngraph_function, parse_transform(argv.transform))
+    apply_moc_transformations(ngraph_function)
 
     if argv.compress_fp16:
         from mo.back.offline_transformations import compress_model
-        compress_model(network)
+        compress_model(ngraph_function)
 
     orig_model_name = os.path.normpath(os.path.join(output_dir, argv.model_name))
-    network.serialize(orig_model_name + ".xml", orig_model_name + ".bin")
+
+    from openvino.offline_transformations_pybind import serialize # pylint: disable=import-error,no-name-in-module
+    serialize(ngraph_function, (orig_model_name + ".xml").encode('utf-8'), (orig_model_name + ".bin").encode('utf-8'))
 
     del argv.feManager
 

model-optimizer/mo/utils/check_ie_bindings.py

@@ -39,7 +39,7 @@ def send_telemetry(mo_version: str, message: str, event_type: str):
 
 def import_core_modules(silent: bool, path_to_module: str):
     """
-        This function checks that InferenceEngine Python API is available
+        This function checks that OpenVINO Python API is available
         and necessary python modules exists. So the next list of imports
         must contain all IE/NG Python API imports that are used inside MO.
 
@@ -48,21 +48,16 @@ def import_core_modules(silent: bool, path_to_module: str):
     :return: True if all imports were successful and False otherwise
     """
     try:
-        from openvino.inference_engine import get_version, IENetwork  # pylint: disable=import-error,no-name-in-module
-        from openvino.offline_transformations import ApplyMOCTransformations, ApplyLowLatencyTransformation  # pylint: disable=import-error,no-name-in-module
-        from openvino.offline_transformations import ApplyMakeStatefulTransformation, GenerateMappingFile  # pylint: disable=import-error,no-name-in-module
-        from openvino.offline_transformations import GenerateMappingFile, ApplyMakeStatefulTransformation, Serialize  # pylint: disable=import-error,no-name-in-module
+        from openvino.offline_transformations_pybind import apply_moc_transformations, apply_low_latency_transformation  # pylint: disable=import-error,no-name-in-module
+        from openvino.offline_transformations_pybind import apply_make_stateful_transformation, generate_mapping_file  # pylint: disable=import-error,no-name-in-module
+        from openvino.offline_transformations_pybind import generate_mapping_file, apply_make_stateful_transformation, serialize  # pylint: disable=import-error,no-name-in-module
 
-        # TODO: it is temporary import to check that nGraph python API is available. But in future
-        # we need to replace it with Frontend imports
-        from ngraph.impl import Function  # pylint: disable=import-error,no-name-in-module
-        from ngraph.impl.op import Parameter  # pylint: disable=import-error,no-name-in-module
-        from _pyngraph import PartialShape, Dimension  # pylint: disable=import-error,no-name-in-module
-        from ngraph.frontend import FrontEndManager, FrontEnd  # pylint: disable=no-name-in-module,import-error
+        from openvino.runtime import Function, get_version  # pylint: disable=import-error,no-name-in-module
+        from openvino.runtime.impl.op import Parameter  # pylint: disable=import-error,no-name-in-module
+        from openvino.runtime import PartialShape, Dimension  # pylint: disable=import-error,no-name-in-module
+        from openvino.frontend import FrontEndManager, FrontEnd  # pylint: disable=no-name-in-module,import-error
 
-        import openvino  # pylint: disable=import-error,no-name-in-module
-        import ngraph  # pylint: disable=import-error,no-name-in-module
-        import ngraph.frontend  # pylint: disable=import-error,no-name-in-module
+        import openvino.frontend  # pylint: disable=import-error,no-name-in-module
 
         if silent:
             return True
@@ -70,10 +65,8 @@ def import_core_modules(silent: bool, path_to_module: str):
         ie_version = str(get_version())
         mo_version = str(v.get_version())  # pylint: disable=no-member,no-name-in-module
 
-        print("\t- {}: \t{}".format("Inference Engine found in", os.path.dirname(openvino.__file__)))
-        # TODO: when nGraph version will be available we need to start compare it to IE and MO versions. Ticket: 58091
-        print("\t- {}: \t{}".format("nGraph found in", os.path.dirname(ngraph.__file__)))
-        print("{}: \t{}".format("Inference Engine version", ie_version))
+        print("\t- {}: \t{}".format("OpenVINO runtime found in", os.path.dirname(openvino.__file__)))
+        print("{}: \t{}".format("OpenVINO runtime version", ie_version))
         print("{}: \t{}".format("Model Optimizer version", mo_version))
 
         versions_mismatch = False
@@ -82,8 +75,8 @@ def import_core_modules(silent: bool, path_to_module: str):
             extracted_mo_release_version = v.extract_release_version(mo_version)
             mo_is_custom = extracted_mo_release_version == (None, None)
 
-            print("[ WARNING ] Model Optimizer and Inference Engine versions do no match.")
-            print("[ WARNING ] Consider building the Inference Engine Python API from sources or reinstall OpenVINO "
+            print("[ WARNING ] Model Optimizer and OpenVINO runtime versions do no match.")
+            print("[ WARNING ] Consider building the OpenVINO Python API from sources or reinstall OpenVINO "
                   "(TM) toolkit using", end=" ")
             if mo_is_custom:
                 print("\"pip install openvino\" (may be incompatible with the current Model Optimizer version)")
@@ -103,7 +96,7 @@ def import_core_modules(silent: bool, path_to_module: str):
     except Exception as e:
         # Do not print a warning if module wasn't found or silent mode is on
         if "No module named 'openvino" not in str(e):
-            print("[ WARNING ] Failed to import Inference Engine Python API in: {}".format(path_to_module))
+            print("[ WARNING ] Failed to import OpenVINO Python API in: {}".format(path_to_module))
             print("[ WARNING ] {}".format(e))
 
             # Send telemetry message about warning

model-optimizer/mo/utils/ie_version.py

@@ -3,7 +3,7 @@
 
 def get_ie_version():
     try:
-        from openvino.inference_engine import get_version  # pylint: disable=import-error,no-name-in-module
+        from openvino.runtime import get_version  # pylint: disable=import-error,no-name-in-module
         return get_version()
     except:
         return None

model-optimizer/unit_tests/mo/frontend_ngraph_test_actual.py

@@ -24,9 +24,9 @@ try:
         mock_return_partial_shape
 
     # pylint: disable=no-name-in-module,import-error
-    from ngraph import PartialShape
-    from ngraph.frontend import FrontEndManager
-    from ngraph.utils.types import get_element_type
+    from openvino.runtime import PartialShape
+    from openvino.frontend import FrontEndManager
+    from openvino.runtime.utils.types import get_element_type
 
 except Exception:
     print("No mock frontend API available, "

model-optimizer/unit_tests/mo/moc_frontend/moc_extractor_test_actual.py

@@ -18,7 +18,7 @@ try:
         clear_setup, set_equal_data, set_max_port_counts
 
     # pylint: disable=no-name-in-module,import-error
-    from ngraph.frontend import FrontEndManager
+    from openvino.frontend import FrontEndManager
 
 except Exception:
     print("No mock frontend API available, "