bigdl-core-npu 2.6.0b20241112__cp310-cp310-win_amd64.whl → 2.6.0b20241114__cp310-cp310-win_amd64.whl

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

@@ -8,6 +8,7 @@ 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
 
 
 
@@ -90,76 +91,85 @@ def get_value_from_list_or_dict(container, name, 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.example_input
-    data_types = args.placeholder_data_types or {}
-    input_shapes = args.placeholder_shapes or {}
+    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)
-    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:
+        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 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)
+    if input_names and not is_dict_input:
+        example_inputs = dict(zip(input_names, example_inputs))
+    print(input_names)
+    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

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

@@ -1,11 +1,13 @@
 # Copyright (C) 2018-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-import os
-from typing import Iterable, Union
-
+import importlib.util
+import logging as log
 import numpy as np
+import os
+import sys
 from openvino.tools.ovc.error import Error
+from typing import Iterable, Union
 
 try:
     import openvino_telemetry as tm
@@ -13,6 +15,11 @@ try:
 except ImportError:
     import openvino.tools.ovc.telemetry_stub as tm
 
+if sys.version_info < (3, 8):
+    import importlib_metadata
+else:
+    import importlib.metadata as importlib_metadata
+
 dynamic_dimension = np.ma.masked
 
 
@@ -107,3 +114,83 @@ def get_ir_version():
     :return: the IR version
     """
     return 11
+
+
+def import_openvino_tokenizers():
+    # extract openvino version
+    if importlib.util.find_spec("openvino") is None:
+        return False
+    try:
+        from openvino import get_version
+        openvino_version = get_version()
+        openvino_available = True
+    except ImportError:
+        openvino_available = False
+    if not openvino_available:
+        return False
+
+    if importlib.util.find_spec("openvino_tokenizers") is None:
+        return False
+
+    try:
+        pip_metadata_version = importlib_metadata.version("openvino")
+    except importlib_metadata.PackageNotFoundError:
+        pip_metadata_version = False
+    try:
+        pip_metadata_version = importlib_metadata.version("openvino-nightly")
+        is_nightly = True
+    except importlib_metadata.PackageNotFoundError:
+        is_nightly = False
+
+    try:
+        import openvino_tokenizers  # pylint: disable=no-name-in-module,import-error
+
+        openvino_tokenizers._get_factory()
+    except RuntimeError:
+        tokenizers_version = openvino_tokenizers.__version__
+
+        if tokenizers_version == "0.0.0.0":
+            try:
+                tokenizers_version = importlib_metadata.version("openvino_tokenizers") or tokenizers_version
+            except importlib_metadata.PackageNotFoundError:
+                pass
+        message = (
+            "OpenVINO and OpenVINO Tokenizers versions are not binary compatible.\n"
+            f"OpenVINO version:            {openvino_version}\n"
+            f"OpenVINO Tokenizers version: {tokenizers_version}\n"
+            "First 3 numbers should be the same. Update OpenVINO Tokenizers to compatible version. "
+        )
+        if not pip_metadata_version:
+            message += (
+                "For archive installation of OpenVINO try to build OpenVINO Tokenizers from source: "
+                "https://github.com/openvinotoolkit/openvino_tokenizers/tree/master?tab=readme-ov-file"
+                "#build-and-install-from-source"
+            )
+            if sys.platform == "linux":
+                message += (
+                    "\nThe PyPI version of OpenVINO Tokenizers is built on CentOS and may not be compatible with other "
+                    "Linux distributions; rebuild OpenVINO Tokenizers from source."
+                )
+        else:
+            message += (
+                "It is recommended to use the same day builds for pre-release version. "
+                "To install both OpenVINO and OpenVINO Tokenizers release version perform:\n"
+            )
+            if is_nightly:
+                message += "pip uninstall -y openvino-nightly && "
+            message += "pip install --force-reinstall openvino openvino-tokenizers\n"
+            if is_nightly:
+                message += (
+                    "openvino-nightly package will be deprecated in the future - use pre-release drops instead. "
+                )
+            message += "To update both OpenVINO and OpenVINO Tokenizers to the latest pre-release version perform:\n"
+            if is_nightly:
+                message += "pip uninstall -y openvino-nightly && "
+            message += (
+                "pip install --pre -U openvino openvino-tokenizers "
+                "--extra-index-url https://storage.openvinotoolkit.org/simple/wheels/nightly"
+            )
+        log.warning(message)
+        return False
+
+    return True

intel_npu_acceleration_library/external/openvino/utils.py

@@ -6,6 +6,7 @@ import os
 import sys
 from functools import wraps
 from typing import Callable, Any
+from pathlib import Path
 
 
 def _add_openvino_libs_to_search_path() -> None:
@@ -38,6 +39,22 @@ def _add_openvino_libs_to_search_path() -> None:
                 os.add_dll_directory(os.path.abspath(lib_path))
 
 
+def get_cmake_path() -> str:
+    """Searches for the directory containing CMake files within the package install directory.
+
+    :return: The path to the directory containing CMake files, if found. Otherwise, returns empty string.
+    :rtype: str
+    """
+    package_path = Path(__file__).parent
+    cmake_file = "OpenVINOConfig.cmake"
+
+    for dirpath, _, filenames in os.walk(package_path):
+        if cmake_file in filenames:
+            return dirpath
+
+    return ""
+
+
 def deprecated(name: Any = None, version: str = "", message: str = "", stacklevel: int = 2) -> Callable[..., Any]:
     """Prints deprecation warning "{function_name} is deprecated and will be removed in version {version}. {message}" and runs the function.
 

intel_npu_acceleration_library/nn/module.py

@@ -67,23 +67,23 @@ def compute_input_signature(
     return "_".join(signature)
 
 
-def patch_parameters(module: torch.nn.Module, model: NNFactory, recurse: bool = False):
-    """Patch the parameters of a PyTorch module with constants.
-
-    Args:
-        module (torch.nn.Module): The PyTorch module.
-        model (NNFactory): The NNFactory instance.
-        recurse (bool, optional): Recurse over all submodules. Defaults to False.
-    """
-    elements = list(module.named_parameters(recurse=recurse))
-    for name, param in elements:
-        del module._parameters[name]
-        setattr(module, name, model.constant(param.data.detach().numpy()))
-
-    buffers = list(module.named_buffers(recurse=recurse))
-    for name, param in buffers:
-        del module._buffers[name]
-        setattr(module, name, model.constant(param.data.detach().numpy()))
+# def patch_parameters(module: torch.nn.Module, model: NNFactory, recurse: bool = False):
+#     """Patch the parameters of a PyTorch module with constants.
+
+#     Args:
+#         module (torch.nn.Module): The PyTorch module.
+#         model (NNFactory): The NNFactory instance.
+#         recurse (bool, optional): Recurse over all submodules. Defaults to False.
+#     """
+#     elements = list(module.named_parameters(recurse=recurse))
+#     for name, param in elements:
+#         del module._parameters[name]
+#         setattr(module, name, model.constant(param.data.detach().numpy()))
+
+#     buffers = list(module.named_buffers(recurse=recurse))
+#     for name, param in buffers:
+#         del module._buffers[name]
+#         setattr(module, name, model.constant(param.data.detach().numpy()))
 
 
 def patch_modules(module: torch.nn.Module, model: NNFactory):