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

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,98 @@
+# -*- 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
+
+
+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 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)