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

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

@@ -0,0 +1,196 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+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
+    from openvino_telemetry.backend import backend_ga4
+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
+
+
+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
+
+
+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/tools/ovc/version.py

@@ -0,0 +1,80 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import re
+
+from openvino.runtime import get_version as get_ie_version  # pylint: disable=no-name-in-module,import-error
+
+
+def extract_release_version(version: str):
+    patterns = [
+        # captures release version set by CI for example: '2021.1.0-1028-55e4d5673a8'
+        r"^([0-9]+).([0-9]+)*",
+        # captures release version generated by MO from release branch, for example: 'custom_releases/2021/1_55e4d567'
+        r"_releases/([0-9]+)/([0-9]+)_*"
+    ]
+
+    for pattern in patterns:
+        m = re.search(pattern, version)
+        if m and len(m.groups()) == 2:
+            return m.group(1), m.group(2)
+    return None, None
+
+
+def simplify_version(version: str):
+    release_version = extract_release_version(version)
+    if release_version == (None, None):
+        return "custom"
+    return "{}.{}".format(*release_version)
+
+
+def get_simplified_ie_version(version=None):
+    from openvino.runtime import get_version  # pylint: disable=no-name-in-module,import-error
+    if version is None:
+        version = get_version()
+
+    # To support legacy OV versions
+    m = re.match(r"^([0-9]+).([0-9]+).(.*)", version)
+    if m and len(m.groups()) == 3:
+        return simplify_version(m.group(3))
+    return simplify_version(version)
+
+
+def extract_hash_from_version(full_version: str):
+    res = re.findall(r'[-_]([a-f0-9]{7,40})', full_version)
+    if len(res) > 0:
+        return res[0]
+    else:
+        return None
+
+
+class SingletonMetaClass(type):
+    def __init__(self, cls_name, super_classes, dic):
+        self.__single_instance = None
+        super().__init__(cls_name, super_classes, dic)
+
+    def __call__(cls, *args, **kwargs):
+        if cls.__single_instance is None:
+            cls.__single_instance = super(SingletonMetaClass, cls).__call__(*args, **kwargs)
+        return cls.__single_instance
+
+
+class VersionChecker(metaclass=SingletonMetaClass):
+    def __init__(self):
+        self.runtime_checked = False
+        self.mo_version = None
+        self.ie_version = None
+        self.mo_simplified_version = None
+        self.ie_simplified_version = None
+
+    def get_ie_version(self):
+        if self.ie_version:
+            return self.ie_version
+        self.ie_version = get_ie_version()
+        return self.ie_version
+
+    def get_ie_simplified_version(self):
+        if self.ie_simplified_version:
+            return self.ie_simplified_version
+        self.ie_simplified_version = get_simplified_ie_version()
+        return self.ie_simplified_version

intel_npu_acceleration_library/external/openvino/torch/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from openvino.frontend.pytorch.torchdynamo import backend

intel_npu_acceleration_library/external/openvino/utils.py

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+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:
+    """Add OpenVINO libraries to the DLL search path on Windows."""
+    if sys.platform == "win32":
+        # Installer, yum, pip installs openvino dlls to the different directories
+        # and those paths need to be visible to the openvino modules
+        #
+        # If you're using a custom installation of openvino,
+        # add the location of openvino dlls to your system PATH.
+        openvino_libs = []
+        if os.path.isdir(os.path.join(os.path.dirname(__file__), "libs")):
+            # looking for the libs in the pip installation path.
+            openvino_libs.append(os.path.join(os.path.dirname(__file__), "libs"))
+        elif os.path.isdir(os.path.join(os.path.dirname(__file__), "..", "..", "..", "Library", "bin")):
+            # looking for the libs in the conda installation path
+            openvino_libs.append(os.path.join(os.path.dirname(__file__), "..", "..", "..", "Library", "bin"))
+        else:
+            # setupvars.bat script set all libs paths to OPENVINO_LIB_PATHS environment variable.
+            openvino_libs_installer = os.getenv("OPENVINO_LIB_PATHS")
+            if openvino_libs_installer:
+                openvino_libs.extend(openvino_libs_installer.split(";"))
+            else:
+                sys.exit("Error: Please set the OPENVINO_LIB_PATHS environment variable. "
+                         "If you use an install package, please, run setupvars.bat")
+        for lib in openvino_libs:
+            lib_path = os.path.join(os.path.dirname(__file__), lib)
+            if os.path.isdir(lib_path):
+                # On Windows, with Python >= 3.8, DLLs are no longer imported from the PATH.
+                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.
+
+    :param version: The version in which the code will be removed.
+    :param message: A message explaining why the function is deprecated and/or what to use instead.
+    """
+
+    def decorator(wrapped: Callable[..., Any]) -> Callable[..., Any]:
+        @wraps(wrapped)
+        def wrapper(*args: Any, **kwargs: Any) -> Callable[..., Any]:
+            # it must be imported here; otherwise, there are errors with no loaded DLL for Windows
+            from openvino._pyopenvino.util import deprecation_warning
+
+            deprecation_warning(wrapped.__name__ if name is None else name, version, message, stacklevel)
+            return wrapped(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+# WA method since Python 3.11 does not support @classmethod and @property chain,
+# currently only read-only properties are supported.
+class _ClassPropertyDescriptor(object):
+    def __init__(self, fget: Callable):
+        self.fget = fget
+
+    def __get__(self, obj: Any, cls: Any = None) -> Any:
+        if cls is None:
+            cls = type(obj)
+        return self.fget.__get__(obj, cls)()
+
+
+def classproperty(func: Any) -> _ClassPropertyDescriptor:
+    if not isinstance(func, (classmethod, staticmethod)):
+        func = classmethod(func)
+    return _ClassPropertyDescriptor(func)
+
+
+def deprecatedclassproperty(name: Any = None, version: str = "", message: str = "", stacklevel: int = 2) -> Callable[[Any], _ClassPropertyDescriptor]:
+    def decorator(wrapped: Any) -> _ClassPropertyDescriptor:
+        func = classproperty(wrapped)
+
+        # Override specific instance
+        def _patch(instance: _ClassPropertyDescriptor, func: Callable[..., Any]) -> None:
+            cls_: Any = type(instance)
+
+            class _(cls_):  # noqa: N801
+                @func
+                def __get__(self, obj: Any, cls: Any = None) -> Any:
+                    return super().__get__(obj, cls)
+
+            instance.__class__ = _
+
+        # Add `deprecated` decorator on the top of `__get__`
+        _patch(func, deprecated(name, version, message, stacklevel))
+        return func
+    return decorator

intel_npu_acceleration_library/functional/__init__.py

@@ -0,0 +1,8 @@
+#
+# Copyright © 2024 Intel Corporation
+# SPDX-License-Identifier: Apache 2.0
+#
+
+from .scaled_dot_product_attention import scaled_dot_product_attention
+
+__all__ = ["scaled_dot_product_attention"]

intel_npu_acceleration_library/functional/scaled_dot_product_attention.py

@@ -0,0 +1,47 @@
+#
+# Copyright © 2024 Intel Corporation
+# SPDX-License-Identifier: Apache 2.0
+#
+from intel_npu_acceleration_library.backend import run_factory, SDPA, SimpleSDPA
+from typing import Optional
+from functools import partial
+import torch
+
+
+def scaled_dot_product_attention(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    value: torch.Tensor,
+    attn_mask: torch.Tensor = None,
+    dropout_p: float = 0.0,
+    is_causal: bool = False,
+    scale: Optional[float] = None,
+) -> torch.Tensor:
+    """Execute SDPA kernel.
+
+    Args:
+        query (torch.Tensor): query tensor
+        key (torch.Tensor): key tensor
+        value (torch.Tensor): value tensor
+        attn_mask (torch.Tensor, optional): attention mask tensor. Defaults to None.
+        dropout_p (float, optional): optional dropout. Defaults to 0.0.
+        is_causal (bool, optional): enable causal mask. Defaults to False.
+        scale (Optional[float], optional): custom scale. Defaults to None.
+
+    Raises:
+        RuntimeError: _description_
+
+    Returns:
+        torch.Tensor: _description_
+    """
+    if dropout_p != 0:
+        raise RuntimeError("dropout_p != 0 is not supported yet")
+    if scale is not None:
+        raise RuntimeError("scale != 0 is not supported yet")
+
+    if attn_mask is None:
+        backend_cls = partial(SimpleSDPA, is_causal=is_causal)  # type: ignore
+        return run_factory([query, key, value], [], backend_cls)
+    else:
+        backend_cls = partial(SDPA, is_causal=is_causal)  # type: ignore
+        return run_factory([query, key, value, attn_mask], [], backend_cls)