bigdl-core-npu 2.5.0__cp311-cp311-win_amd64.whl

intel_npu_acceleration_library/external/openvino/tools/ovc/moc_frontend/pytorch_frontend_utils.py

@@ -0,0 +1,205 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import logging as log
+import sys
+
+import numpy as np
+# pylint: disable=no-name-in-module,import-error
+from openvino.runtime import Tensor, PartialShape
+from openvino.tools.ovc.error import Error
+
+
+
+def get_pytorch_decoder(model, example_inputs, args):
+    try:
+        from openvino.frontend.pytorch.ts_decoder import TorchScriptPythonDecoder
+        from openvino.frontend.pytorch.fx_decoder import TorchFXPythonDecoder
+        from openvino.frontend.pytorch.module_extension import ModuleExtension
+        import torch
+    except Exception as e:
+        log.error("PyTorch frontend loading failed")
+        raise e
+    
+    def extract_module_extensions(args):
+        extensions = args.get('extension', []) or []
+        if not isinstance(extensions, (list, tuple)):
+            extensions = [extensions]
+        return {extension.module: extension for extension in extensions if isinstance(extension, ModuleExtension)}
+
+    if 'nncf' in sys.modules:
+        is_good_version = True
+        try:
+            from nncf.torch.nncf_network import NNCFNetwork
+
+            if isinstance(model, NNCFNetwork):
+                from packaging import version
+                if version.parse(sys.modules['nncf'].__version__) < version.parse("2.6"):
+                    is_good_version = False
+        except:
+            pass
+        if not is_good_version:
+            raise RuntimeError(
+                "NNCF models produced by nncf<2.6 are not supported directly. Please upgrade nncf or export to ONNX first.")
+    inputs = prepare_torch_inputs(example_inputs)
+    if not isinstance(model, (TorchScriptPythonDecoder, TorchFXPythonDecoder)):
+        if hasattr(torch, "export") and isinstance(model, (torch.export.ExportedProgram)):
+            from packaging import version
+            if version.parse(torch.__version__) >= version.parse("2.2"):
+                model = model.run_decompositions()
+            gm = model.module()
+            decoder = TorchFXPythonDecoder(gm)
+        else:
+            decoder = TorchScriptPythonDecoder(
+                model,
+                example_input=inputs,
+                shared_memory=args.get("share_weights", True),
+                module_extensions=extract_module_extensions(args))
+    else:
+        decoder = model
+    args['input_model'] = decoder
+    args["example_input"] = inputs
+
+    return args
+
+
+def update_list_or_dict(container, name, idx, value):
+    if isinstance(container, dict):
+        if name is None:
+            name = list(container)[idx]
+        container[name] = value
+        return
+    if idx == len(container):
+        container.append(value)
+    elif idx > len(container):
+        raise Error(f"Wrong {idx}")
+    else:
+        container[idx] = value
+    return
+
+
+def get_value_from_list_or_dict(container, name, idx):
+    if isinstance(container, dict):
+        if name is None:
+            if idx < len(container):
+                name = list(container)[idx]
+            return None
+        return container.get(name)
+    if idx < len(container):
+        return container[idx]
+    return None
+
+
+def extract_input_info_from_example(args, inputs):
+    try:
+        from openvino.frontend.pytorch.utils import pt_to_ov_type_map  # pylint: disable=no-name-in-module,import-error
+    except Exception as e:
+        log.error("PyTorch frontend loading failed")
+        raise e
+    example_inputs = args.example_input
+    data_types = args.placeholder_data_types or {}
+    input_shapes = args.placeholder_shapes or {}
+    is_dict_input = isinstance(example_inputs, dict)
+    list_inputs = list(example_inputs.values()) if is_dict_input else example_inputs
+    input_names = None
+    if not isinstance(example_inputs, (list, tuple, dict)):
+        list_inputs = [list_inputs]
+    if args.input_model._input_is_list:
+        list_inputs[0] = list_inputs[0].unsqueeze(0)
+    if args.input_model._input_signature is not None and not is_dict_input:
+        input_names = args.input_model._input_signature[1:] if args.input_model._input_signature[
+                                                                   0] == "self" else args.input_model._input_signature
+        if not is_dict_input:
+            example_inputs = dict(zip(input_names, list_inputs))
+            is_dict_input = True
+    elif is_dict_input:
+        input_names = list(example_inputs)
+    if not data_types and input_names is None:
+        data_types = []
+    if not input_shapes and input_names is None:
+        input_shapes = []
+    if inputs:
+        for input_id, input_info in enumerate(inputs):
+            input_name = input_info.name
+            if is_dict_input and input_name in example_inputs:
+                example_input = example_inputs[input_name]
+            else:
+                example_input = list_inputs[input_id]
+                if is_dict_input and input_name is None:
+                    input_name = input_names[input_id]
+            dtype = getattr(example_input, "dtype", type(example_input))
+            example_dtype = pt_to_ov_type_map.get(str(dtype))
+            user_dtype = get_value_from_list_or_dict(data_types, input_name, input_id)
+            if user_dtype is not None and example_dtype is not None and example_dtype != user_dtype:
+                raise Error(
+                    f"Defined input type {user_dtype} is not equal to provided example_input type {example_dtype}")
+
+            data_rank = getattr(example_input, "ndim", 0)
+            user_input_shape = get_value_from_list_or_dict(input_shapes, input_name, input_id)
+            if user_input_shape.rank.is_static and user_input_shape.rank.get_length() != data_rank:
+                raise Error(
+                    f"Requested input shape {user_input_shape.rank.get_length()} rank"
+                    f" is not equal to provided example_input rank {data_rank}")
+
+            input_shape = user_input_shape if user_input_shape is not None else PartialShape([-1] * data_rank)
+            update_list_or_dict(data_types, input_name, input_id,
+                                example_dtype if example_dtype is not None else None)
+            update_list_or_dict(input_shapes, input_name, input_id, input_shape)
+    else:
+        for input_id, example_input in enumerate(list_inputs):
+            dtype = getattr(example_input, "dtype", type(example_input))
+            ov_dtype = pt_to_ov_type_map.get(str(dtype))
+            data_rank = getattr(example_input, "ndim", 0)
+            input_shape = PartialShape([-1] * data_rank)
+            input_name = input_names[input_id] if input_names else None
+            update_list_or_dict(input_shapes, input_name, input_id, input_shape)
+            update_list_or_dict(data_types, input_name, input_id, ov_dtype if ov_dtype is not None else None)
+
+    args.placeholder_data_types = data_types
+    args.placeholder_shapes = input_shapes
+    if not args.input and input_names:
+        args.input_list = input_names
+        args.input = ",".join(input_names)
+
+
+# pylint: disable=no-member
+def to_torch_tensor(tensor):
+    import torch  # pylint: disable=import-error
+    if isinstance(tensor, torch.Tensor):
+        return tensor
+    if isinstance(tensor, np.ndarray):
+        return torch.tensor(tensor)
+    if isinstance(tensor, Tensor):
+        return torch.tensor(tensor.data)
+    if isinstance(tensor, (float, int, bool)):
+        return tensor
+    if isinstance(tensor, (tuple, list)):
+        # TODO: Function to_torch_tensor should be renamed as it handles not only a tensor
+        return tuple(to_torch_tensor(x) for x in tensor)
+    if isinstance(tensor, dict) and all(isinstance(k, str) for k in tensor.keys()):
+        return dict((k, to_torch_tensor(x)) for k, x in tensor.items())
+    else:
+        raise Error("Unexpected type of example_input. Supported types torch.Tensor, np.array or ov.Tensor. "
+                    "Got {}".format(type(tensor)))
+
+
+def prepare_torch_inputs(example_inputs):
+    inputs = None
+    if example_inputs is not None:
+        inputs = example_inputs
+        if isinstance(inputs, list):
+            inputs = [to_torch_tensor(x) for x in inputs]
+        elif isinstance(inputs, tuple):
+            inputs = [to_torch_tensor(x) for x in inputs]
+            inputs = tuple(inputs)
+        elif isinstance(inputs, dict):
+            for name, tensor in inputs.items():
+                assert isinstance(name, str), "Expected dictionary where keys are input names of string type and" \
+                                              " values are tensors. Got key of type {}".format(type(name))
+                inputs[name] = to_torch_tensor(tensor)
+        else:
+            inputs = to_torch_tensor(inputs)
+    else:
+        # No example_input were provided, decoder will use scripting
+        return None
+    return inputs

intel_npu_acceleration_library/external/openvino/tools/ovc/moc_frontend/shape_utils.py

@@ -0,0 +1,109 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import sys
+
+import numpy as np
+from openvino.runtime import Shape, PartialShape, Dimension  # pylint: disable=no-name-in-module,import-error
+from openvino.tools.ovc.error import Error
+
+
+def get_static_shape(shape: [PartialShape, list, tuple], dynamic_value=None):
+    # Current function returns list with static dimensions with following logic.
+    # For dynamic dimensions return lower boundaries if they are set, otherwise
+    # return upper boundaries if they are set. If dimension is fully dynamic then raise error.
+    shape_list = []
+    for idx, dim in enumerate(shape):
+        if isinstance(dim, int):
+            if dim == -1:
+                shape_list.append(dynamic_value)
+                continue
+            shape_list.append(dim)
+        elif isinstance(dim, np.int64):
+            if dim == np.int64(-1):
+                shape_list.append(dynamic_value)
+                continue
+            shape_list.append(dim)
+        elif isinstance(dim, tuple):
+            # tuple where (min_length, max_length), the format which uses MO cli parser
+            assert len(dim) == 2, "Unknown dimension type {}".format(dim)
+            if dim[0] > 0:
+                shape_list.append(dim[0])
+            elif dim[1] < np.iinfo(np.int64).max:
+                shape_list.append(dim[1])
+            else:
+                shape_list.append(dynamic_value)
+                continue
+        elif isinstance(dim, Dimension):
+            if dim.is_static or dim.get_min_length() > 0:
+                shape_list.append(dim.get_min_length())
+            elif dim.get_max_length() != -1:
+                shape_list.append(dim.get_max_length())
+            else:
+                shape_list.append(dynamic_value)
+                continue
+        else:
+            raise Error("Unknown dimension type {}".format(dim))
+
+    return tuple(shape_list)
+
+
+def get_dynamic_dims(shape: [PartialShape, list, tuple]):
+    dynamic_dims = []
+    for idx, dim in enumerate(shape):
+        if isinstance(dim, int):
+            if dim == -1:
+                dynamic_dims.append(idx)
+        if isinstance(dim, np.int64):
+            if dim == np.int64(-1):
+                dynamic_dims.append(idx)
+        elif isinstance(dim, tuple):
+            dynamic_dims.append(idx)
+        elif isinstance(dim, Dimension):
+            if dim.get_min_length() == 0 and dim.get_max_length() == -1:
+                dynamic_dims.append(idx)
+
+    return dynamic_dims
+
+
+def tensor_to_int_list(tensor):
+    assert hasattr(tensor, 'numpy'), "Could not get value of provided tensor: {}".format(tensor)
+    tensor_numpy = tensor.numpy()
+    assert tensor_numpy.dtype == np.int32, "Unexpected type of provided tensor. Expected int32, got: {}".format(
+        tensor_numpy.dtype)
+    return tensor_numpy.tolist()
+
+
+def to_partial_shape(shape):
+    if 'tensorflow' in sys.modules:
+        import tensorflow as tf  # pylint: disable=import-error
+        if isinstance(shape, tf.Tensor):
+            return PartialShape(tensor_to_int_list(shape))
+        if isinstance(shape, tf.TensorShape):
+            return PartialShape(list(shape))
+    if 'paddle' in sys.modules:
+        import paddle
+        if isinstance(shape, paddle.Tensor):
+            return PartialShape(tensor_to_int_list(shape))
+    return PartialShape(shape)
+
+
+def is_shape_type(value):
+    if isinstance(value, PartialShape):
+        return True
+    if 'tensorflow' in sys.modules:
+        import tensorflow as tf # pylint: disable=import-error
+        if isinstance(value, (tf.TensorShape, tf.Tensor)):
+            return True
+    if 'paddle' in sys.modules:
+        import paddle
+        if isinstance(value, paddle.Tensor):
+            return True
+    if isinstance(value, Shape):
+        return True
+    if isinstance(value, list) or isinstance(value, tuple):
+        for dim in value:
+            if not (isinstance(dim, Dimension) or isinstance(dim, int)):
+                return False
+        return True
+    return False

intel_npu_acceleration_library/external/openvino/tools/ovc/moc_frontend/type_utils.py

@@ -0,0 +1,82 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import sys
+
+import numpy as np
+
+import openvino as ov
+from openvino.runtime import Type
+
+
+def is_type(val):
+    if isinstance(val, (type, Type)):
+        return True
+    if 'tensorflow' in sys.modules:
+        import tensorflow as tf # pylint: disable=import-error
+        if isinstance(val, tf.dtypes.DType):
+            return True
+    if 'torch' in sys.modules:
+        import torch
+        if isinstance(val, torch.dtype):
+            return True
+    if 'paddle' in sys.modules:
+        import paddle
+        if isinstance(val, paddle.dtype):
+            return True
+    return False
+
+
+def to_ov_type(val):
+    if isinstance(val, Type):
+        return val
+    if isinstance(val, (type, str, np.dtype)):
+        return Type(val)
+    if 'tensorflow' in sys.modules:
+        import tensorflow as tf # pylint: disable=import-error
+        if isinstance(val, tf.dtypes.DType):
+            from openvino.frontend.tensorflow.utils import tf_type_to_ov_type  # pylint: disable=no-name-in-module,import-error
+            return tf_type_to_ov_type(val)
+    if 'torch' in sys.modules:
+        import torch
+
+        if isinstance(val, torch.dtype):
+            torch_to_ov_type = {
+                torch.float32: ov.Type.f32,
+                torch.float16: ov.Type.f16,
+                torch.float64: ov.Type.f64,
+                torch.bfloat16: ov.Type.bf16,
+                torch.uint8: ov.Type.u8,
+                torch.int8: ov.Type.i8,
+                torch.int16: ov.Type.i16,
+                torch.int32: ov.Type.i32,
+                torch.int64: ov.Type.i64,
+                torch.bool: ov.Type.boolean,
+            }
+            if val not in torch_to_ov_type:
+                raise Exception("The provided data time is not supported {}.".format(val))
+
+            return torch_to_ov_type[val]
+
+    if 'paddle' in sys.modules:
+        import paddle
+
+        if isinstance(val, paddle.dtype):
+            paddle_to_ov_type = {
+                paddle.float32: ov.Type.f32,
+                paddle.float16: ov.Type.f16,
+                paddle.float64: ov.Type.f64,
+                paddle.bfloat16: ov.Type.bf16,
+                paddle.uint8: ov.Type.u8,
+                paddle.int8: ov.Type.i8,
+                paddle.int16: ov.Type.i16,
+                paddle.int32: ov.Type.i32,
+                paddle.int64: ov.Type.i64,
+                paddle.bool: ov.Type.boolean,
+            }
+
+            if val not in paddle_to_ov_type:
+                raise Exception("The provided data time is not supported {}.".format(val))
+
+            return paddle_to_ov_type[val]
+    raise Exception("Unexpected type object. Expected ov.Type, np.dtype, tf.dtypes.DType. Got {}".format(type(val)))

intel_npu_acceleration_library/external/openvino/tools/ovc/ovc.py

@@ -0,0 +1,13 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# !/usr/bin/env python3
+
+import sys
+
+if __name__ == "__main__":
+    from openvino.tools.ovc.telemetry_utils import init_mo_telemetry
+    from openvino.tools.ovc.main import main
+
+    init_mo_telemetry()
+    sys.exit(main())

intel_npu_acceleration_library/external/openvino/tools/ovc/telemetry_params.py

@@ -0,0 +1,6 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+telemetry_params = {
+    'TID': "G-W5E9RNLD4H"
+}

intel_npu_acceleration_library/external/openvino/tools/ovc/telemetry_stub.py

@@ -0,0 +1,28 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+class Telemetry(object):
+    """
+    Stab file for the Telemetry class which is used when Telemetry class is not available.
+    """
+
+    def __init__(self, *arg, **kwargs):
+        pass
+
+    def send_event(self, *arg, **kwargs):
+        pass
+
+    def send_error(self, *arg, **kwargs):
+        pass
+
+    def start_session(self, *arg, **kwargs):
+        pass
+
+    def end_session(self, *arg, **kwargs):
+        pass
+
+    def force_shutdown(self, *arg, **kwargs):
+        pass
+
+    def send_stack_trace(self, *arg, **kwargs):
+        pass

intel_npu_acceleration_library/external/openvino/tools/ovc/telemetry_utils.py

@@ -0,0 +1,118 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import argparse
+import numbers
+import os
+from openvino.runtime import get_version as get_rt_version  # pylint: disable=no-name-in-module,import-error
+from openvino.tools.ovc.cli_parser import get_params_with_paths_list
+from openvino.tools.ovc.telemetry_params import telemetry_params
+from openvino.tools.ovc.utils import check_values_equal
+
+try:
+    import openvino_telemetry as tm
+    from openvino_telemetry.backend import backend_ga4
+except ImportError:
+    import openvino.tools.ovc.telemetry_stub as tm
+
+
+def is_optimum():
+    import traceback
+    for frame_summary in traceback.extract_stack():
+        if os.path.join("optimum", "intel") in frame_summary.filename or \
+                os.path.join("optimum", "exporters", "openvino") in frame_summary.filename:
+            return True
+    return False
+
+
+def init_mo_telemetry(app_name='Model Conversion API', app_version=None):
+    app_version = app_version if app_version is not None else get_rt_version()
+    return init_telemetry_class(tid=get_tid(),
+                                app_name=app_name,
+                                app_version=app_version,
+                                backend='ga4',
+                                enable_opt_in_dialog=False,
+                                disable_in_ci=True
+                                )
+
+
+def init_telemetry_class(tid,
+                         app_name,
+                         app_version,
+                         backend,
+                         enable_opt_in_dialog,
+                         disable_in_ci):
+    # Init telemetry class
+    telemetry = tm.Telemetry(tid=tid,
+                             app_name=app_name,
+                             app_version=app_version,
+                             backend=backend,
+                             enable_opt_in_dialog=enable_opt_in_dialog,
+                             disable_in_ci=disable_in_ci)
+
+    # Telemetry is a singleton class and if it was already initialized in another tool
+    # some parameters will be incorrect, including app_name.
+    # In this case we need to force reinitialisation of telemetry.
+    if hasattr(telemetry, "backend") and telemetry.backend.app_name != app_name:
+        telemetry.init(tid=tid,
+                       app_name=app_name,
+                       app_version=app_version,
+                       backend=backend,
+                       enable_opt_in_dialog=enable_opt_in_dialog,
+                       disable_in_ci=disable_in_ci)
+    return telemetry
+
+
+def send_framework_info(framework: str):
+    """
+    This function sends information about used framework.
+    :param framework: framework name.
+    """
+    t = tm.Telemetry()
+    t.send_event('ovc', 'framework', framework)
+
+
+def get_tid():
+    """
+    This function returns the ID of the database to send telemetry.
+    """
+    return telemetry_params['TID']
+
+
+def send_conversion_result(conversion_result: str, need_shutdown=False):
+    t = tm.Telemetry()
+    t.send_event('ovc', 'conversion_result', conversion_result)
+    t.end_session('ovc')
+    if need_shutdown:
+        t.force_shutdown(1.0)
+
+
+def arg_to_str(arg):
+    # This method converts to string only known types, otherwise returns string with name of the type
+    from openvino.runtime import PartialShape, Shape, Type, Layout  # pylint: disable=no-name-in-module,import-error
+    if isinstance(arg, (PartialShape, Shape, Type, Layout)):
+        return str(arg)
+    if isinstance(arg, (str, numbers.Number, bool)):
+        return str(arg)
+    return str(type(arg))
+
+
+def send_params_info(argv: argparse.Namespace, cli_parser: argparse.ArgumentParser):
+    """
+    This function sends information about used command line parameters.
+    :param argv: command line parameters.
+    :param cli_parser: command line parameters parser.
+    """
+    t = tm.Telemetry()
+    params_with_paths = get_params_with_paths_list()
+    for arg in vars(argv):
+        arg_value = getattr(argv, arg)
+        if not check_values_equal(arg_value, cli_parser.get_default(arg)):
+            if arg in params_with_paths:
+                # If command line argument value is a directory or a path to file it is not sent
+                # as it may contain confidential information. "1" value is used instead.
+                param_str = arg + ":" + str(1)
+            else:
+                param_str = arg + ":" + arg_to_str(arg_value)
+
+            t.send_event('ovc', 'cli_parameters', param_str)

intel_npu_acceleration_library/external/openvino/tools/ovc/utils.py

@@ -0,0 +1,109 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+from typing import Iterable, Union
+
+import numpy as np
+from openvino.tools.ovc.error import Error
+
+try:
+    import openvino_telemetry as tm
+    from openvino_telemetry.backend import backend_ga4
+except ImportError:
+    import openvino.tools.ovc.telemetry_stub as tm
+
+dynamic_dimension = np.ma.masked
+
+
+def refer_to_faq_msg(question_num: int):
+    try:
+        t = tm.Telemetry()
+        t.send_event('ovc', 'error_info', "faq:" + str(question_num))
+    except Exception:
+        # Telemetry can be not initialized if it is used in MO IR Reader
+        pass
+
+    return '\n For more information please refer to Model Conversion API FAQ, question #{0}. ' \
+           '(https://docs.openvino.ai/2023.0/openvino_docs_MO_DG_prepare_model_Model_Optimizer_FAQ.html' \
+           '?question={0}#question-{0})'.format(question_num)
+
+
+def get_mo_root_dir():
+    """
+    Return the absolute path to the Model Conversion API root directory (where mo folder is located)
+    :return: path to the MO root directory
+    """
+    return os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(os.path.realpath(__file__))), os.pardir))
+
+
+def check_values_equal(val1, val2):
+    # This method is needed to check equality of values where some values can be None
+    if val1 is None and val2 is None:
+        return True
+    if val1 is None:
+        return False
+    if val2 is None:
+        return False
+    return val1 == val2
+
+
+np_map_cast = {bool: lambda x: bool_cast(x),
+               np.int8: lambda x: np.int8(x),
+               np.int16: lambda x: np.int16(x),
+               np.int32: lambda x: np.int32(x),
+               np.int64: lambda x: np.int64(x),
+               np.uint8: lambda x: np.uint8(x),
+               np.uint16: lambda x: np.uint16(x),
+               np.uint32: lambda x: np.uint32(x),
+               np.uint64: lambda x: np.uint64(x),
+               np.float16: lambda x: np.float16(x),
+               np.float32: lambda x: np.float32(x),
+               np.double: lambda x: np.double(x),
+               str: lambda x: str(x)}
+
+
+def bool_cast(x):
+    if isinstance(x, str):
+        return False if x.lower() in ['false', '0'] else True if x.lower() in ['true', '1'] else 'unknown_boolean_cast'
+    else:
+        return bool(x)
+
+
+def mo_array(value: Union[Iterable[Union[float, int]], float, int], dtype=None) -> np.ndarray:
+    """
+    This function acts in a same way as np.array except for the case when dtype is not provided
+    and np.array return fp64 array this function returns fp32 array
+    """
+    x = np.array(value, dtype=dtype)
+    if not isinstance(value, np.ndarray) and x.dtype == np.float64 and dtype != np.float64:
+        x = x.astype(np.float32)
+    return x
+
+
+def validate_batch_in_shape(shape, layer_name: str):
+    """
+    Raises Error #39 if shape is not valid for setting batch size
+    Parameters
+    ----------
+    shape: current shape of layer under validation
+    layer_name: name of layer under validation
+    """
+    if len(shape) == 0 or (shape[0] is not dynamic_dimension and shape[0] not in (-1, 0, 1)):
+        raise Error(('The input layer {} has a shape {} defined in the model. \n\n' +
+                     'When you use "batch" option, Model Conversion API applies its value to the first ' +
+                     'element of the shape if it is equal to -1, 0 or 1. Otherwise, this is the ambiguous ' +
+                     'situation - it is not known in advance whether the layer has the batch ' +
+                     'dimension or not.\n\n For example, you want to set batch dimension equals 100 ' +
+                     'for the input layer "data" with shape (10,34). Although you can not use "batch", ' +
+                     'you should pass "input_shape=[100,34]" instead of "batch=100". \n\n' +
+                     'You can also specify batch dimension by setting "layout". \n\n')
+                    .format(layer_name, shape))
+
+
+def get_ir_version():
+    """
+    Default IR version.
+    :return: the IR version
+    """
+    return 11