bigdl-core-npu 2.6.0b20250114__cp311-cp311-win_amd64.whl

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

@@ -0,0 +1,214 @@
+# 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
+from openvino.tools.ovc.cli_parser import single_input_to_input_cut_info, _InputCutInfo
+
+
+
+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 flatten_inputs(inputs, names=None):
+    flattened = []
+    if isinstance(inputs, dict):
+        # if names are provided we need to unpack in the same order
+        if names:
+            for name in names:
+                if isinstance(inputs[name], (list, tuple, dict)):
+                    flattened.extend(flatten_inputs(inputs[name]))
+                else:
+                    flattened.append((name, inputs[name]))
+        else:
+            for name, input_data in inputs.items():
+                if isinstance(input_data, (list, tuple, dict)):
+                    flattened.extend(flatten_inputs(input_data))
+                else:
+                    flattened.append((name, input_data))
+    else:
+        for input_data in inputs:
+            if isinstance(input_data, (list, tuple, dict)):
+                flattened.extend(flatten_inputs(input_data))
+            else:
+                flattened.append(input_data)
+    return flattened
+
+
+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.input_model._example_input if args.input_model._example_input is not None else args.example_input
+    if example_inputs is None:
+        return
+    is_dict_input = isinstance(example_inputs, dict)
+    if not isinstance(example_inputs, (list, tuple, dict)):
+        example_inputs = [example_inputs]
+    input_names = None
+    if args.input_model._input_signature is not None:
+        input_names = args.input_model._input_signature[1:] if args.input_model._input_signature[
+                                                                   0] == "self" else args.input_model._input_signature
+    if input_names and not is_dict_input:
+        example_inputs = dict(zip(input_names, example_inputs))
+    example_inputs = flatten_inputs(example_inputs, input_names)
+    input_arg = []
+    for example in example_inputs:
+        name = None
+        if isinstance(example, tuple) and len(example) == 2:
+            name = example[0]
+            example = example[1]
+        shape = PartialShape([-1] * example.ndim) if hasattr(example, "ndim") else PartialShape.dynamic()
+        dtype = getattr(example, "dtype", type(example))
+        dtype = pt_to_ov_type_map.get(str(dtype))
+        if name:
+            input_arg.append(single_input_to_input_cut_info((name, shape, dtype)))
+        else:
+            input_arg.append(single_input_to_input_cut_info((shape, dtype)))
+    if inputs is not None and len(inputs) != 0:
+        if len(inputs) == len(input_arg):
+            # we can update input argument with info from examples
+            new_input = []
+            for i in range(len(input_arg)):
+                input_desc = args.input[i]
+                name = input_desc.name
+                dtype = input_desc.type
+                shape = input_desc.shape
+                if name is None:
+                    name = input_arg[i].name
+                if dtype is None:
+                    dtype = input_arg[i].type
+                if shape is None:
+                    shape = input_arg[i].shape
+                new_input.append(_InputCutInfo(name, shape, dtype, input_desc.value))
+            input_arg = new_input
+        else:
+            # we can't update args.input
+            return
+    args.input = input_arg
+
+
+# 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)