bigdl-core-npu 2.5.0__cp310-cp310-win_amd64.whl

intel_npu_acceleration_library/external/openvino/runtime/utils/decorators.py

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from functools import wraps
+from inspect import getfullargspec
+from typing import Any, Callable, List, Optional
+
+from openvino.runtime import Node, Output
+from openvino.runtime.utils.types import NodeInput, as_node, as_nodes
+
+
+def _get_name(**kwargs: Any) -> Node:
+    if "name" in kwargs:
+        return kwargs["name"]
+    return None
+
+
+def _set_node_friendly_name(node: Node, *, name: Optional[str] = None) -> Node:
+    if name is not None:
+        node.friendly_name = name
+    return node
+
+
+def nameable_op(node_factory_function: Callable) -> Callable:
+    """Set the name to the openvino operator returned by the wrapped function."""
+
+    @wraps(node_factory_function)
+    def wrapper(*args: Any, **kwargs: Any) -> Node:
+        node = node_factory_function(*args, **kwargs)
+        node = _set_node_friendly_name(node, name=_get_name(**kwargs))
+        return node
+
+    return wrapper
+
+
+def unary_op(node_factory_function: Callable) -> Callable:
+    """Convert the first input value to a Constant Node if a numeric value is detected."""
+
+    @wraps(node_factory_function)
+    def wrapper(input_value: NodeInput, *args: Any, **kwargs: Any) -> Node:
+        input_node = as_node(input_value, name=_get_name(**kwargs))
+        node = node_factory_function(input_node, *args, **kwargs)
+        node = _set_node_friendly_name(node, name=_get_name(**kwargs))
+        return node
+
+    return wrapper
+
+
+def binary_op(node_factory_function: Callable) -> Callable:
+    """Convert the first two input values to Constant Nodes if numeric values are detected."""
+
+    @wraps(node_factory_function)
+    def wrapper(left: NodeInput, right: NodeInput, *args: Any, **kwargs: Any) -> Node:
+        left, right = as_nodes(left, right, name=_get_name(**kwargs))
+        node = node_factory_function(left, right, *args, **kwargs)
+        node = _set_node_friendly_name(node, name=_get_name(**kwargs))
+        return node
+
+    return wrapper
+
+
+def custom_preprocess_function(custom_function: Callable) -> Callable:
+    """Convert Node returned from custom_function to Output."""
+
+    @wraps(custom_function)
+    def wrapper(node: Node) -> Output:
+        return Output._from_node(custom_function(node))
+
+    return wrapper

intel_npu_acceleration_library/external/openvino/runtime/utils/input_validation.py

@@ -0,0 +1,133 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""Helper functions for validating user input."""
+
+import logging
+from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, Type
+
+import numpy as np
+
+from openvino.runtime.exceptions import UserInputError
+
+log = logging.getLogger(__name__)
+
+
+def assert_list_of_ints(value_list: Iterable[int], message: str) -> None:
+    """Verify that the provided value is an iterable of integers."""
+    try:
+        for value in value_list:
+            if not isinstance(value, int):
+                raise TypeError
+    except TypeError:
+        log.warning(message)
+        raise UserInputError(message, value_list)
+
+
+def _check_value(op_name, attr_key, value, val_type, cond=None):
+    # type: (str, str, Any, Type, Optional[Callable[[Any], bool]]) -> bool
+    """Check whether provided value satisfies specified criteria.
+
+    :param      op_name:        The operator name which attributes are checked.
+    :param      attr_key:       The attribute name.
+    :param      value:          The value to check.
+    :param      val_type:       Required value type.
+    :param      cond:           The optional function running additional checks.
+
+    :raises     UserInputError:
+
+    returns:    True if attribute satisfies all criterias. Otherwise False.
+    """
+    if not np.issubdtype(type(value), val_type):
+        raise UserInputError(
+            f'{op_name} operator attribute "{attr_key}" value must by of type {val_type}.',
+        )
+    if cond is not None and not cond(value):
+        raise UserInputError(
+            f'{op_name} operator attribute "{attr_key}" value does not satisfy provided condition.',
+        )
+    return True
+
+
+def check_valid_attribute(op_name, attr_dict, attr_key, val_type, cond=None, required=False):
+    # type: (str, dict, str, Type, Optional[Callable[[Any], bool]], Optional[bool]) -> bool
+    """Check whether specified attribute satisfies given criteria.
+
+    :param  op_name:    The operator name which attributes are checked.
+    :param attr_dict:   Dictionary containing key-value attributes to check.
+    :param attr_key:    Key value for validated attribute.
+    :param val_type:    Value type for validated attribute.
+    :param cond:        Any callable wich accept attribute value and returns True or False.
+    :param required:    Whether provided attribute key is not required. This mean it may be missing
+                        from provided dictionary.
+
+    :raises     UserInputError:
+
+    returns True if attribute satisfies all criterias. Otherwise False.
+    """
+    result = True
+
+    if required and attr_key not in attr_dict:
+        raise UserInputError(
+            f'Provided dictionary is missing {op_name} operator required attribute "{attr_key}"',
+        )
+
+    if attr_key not in attr_dict:
+        return result
+
+    attr_value = attr_dict[attr_key]
+
+    if np.isscalar(attr_value):
+        result = result and _check_value(op_name, attr_key, attr_value, val_type, cond)
+    else:
+        for value in attr_value:
+            result = result and _check_value(op_name, attr_key, value, val_type, cond)
+
+    return result
+
+
+def check_valid_attributes(
+    op_name,  # type: str
+    attributes,  # type: Dict[str, Any]
+    requirements,  # type: List[Tuple[str, bool, Type, Optional[Callable]]]
+):
+    # type: (...) -> bool
+    """Perform attributes validation according to specified type, value criteria.
+
+    :param  op_name:        The operator name which attributes are checked.
+    :param  attributes:     The dictionary with user provided attributes to check.
+    :param  requirements:   The list of tuples describing attributes' requirements. The tuple should
+                            contain following values:
+                            (attr_name: str,
+                            is_required: bool,
+                            value_type: Type,
+                            value_condition: Callable)
+
+    :raises     UserInputError:
+
+    :returns True if all attributes satisfies criterias. Otherwise False.
+    """
+    for attr, required, val_type, cond in requirements:
+        check_valid_attribute(op_name, attributes, attr, val_type, cond, required)
+    return True
+
+
+def is_positive_value(value):  # type: (Any) -> bool
+    """Determine whether the specified x is positive value.
+
+    :param      value:    The value to check.
+
+    returns   True if the specified x is positive value, False otherwise.
+    """
+    return value > 0
+
+
+def is_non_negative_value(value):  # type: (Any) -> bool
+    """Determine whether the specified x is non-negative value.
+
+    :param      value:    The value to check.
+
+    returns   True if the specified x is non-negative value, False otherwise.
+    """
+    return value >= 0

intel_npu_acceleration_library/external/openvino/runtime/utils/node_factory.py

@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import logging as log
+
+from functools import partial, singledispatchmethod
+from typing import Any, Dict, List, Optional, Union
+from pathlib import Path
+
+from openvino._pyopenvino import NodeFactory as _NodeFactory
+
+from openvino.runtime import Node, Output, Extension
+
+from openvino.runtime.exceptions import UserInputError
+
+DEFAULT_OPSET = "opset13"
+
+
+class NodeFactory(object):
+    """Factory front-end to create node objects."""
+
+    def __init__(self, opset_version: str = DEFAULT_OPSET) -> None:
+        """Create the NodeFactory object.
+
+        :param      opset_version:  The opset version the factory will use to produce ops from.
+        """
+        self.factory = _NodeFactory(opset_version)
+
+    def create(
+        self,
+        op_type_name: str,
+        arguments: Optional[List[Union[Node, Output]]] = None,
+        attributes: Optional[Dict[str, Any]] = None,
+    ) -> Node:
+        """Create node object from provided description.
+
+        The user does not have to provide all node's attributes, but only required ones.
+
+        :param      op_type_name:  The operator type name.
+        :param      arguments:     The operator arguments.
+        :param      attributes:    The operator attributes.
+
+        :return:   Node object representing requested operator with attributes set.
+        """
+        if arguments is None and attributes is None:
+            node = self.factory.create(op_type_name)
+            return node
+
+        if arguments is None and attributes is not None:
+            raise UserInputError(f'Error: cannot create "{op_type_name}" op without arguments.')
+
+        if attributes is None:
+            attributes = {}
+
+        assert arguments is not None
+
+        arguments = self._arguments_as_outputs(arguments)
+        node = self.factory.create(op_type_name, arguments, attributes)
+
+        return node
+
+    @singledispatchmethod
+    def add_extension(self, extension: Union[Path, str, Extension, List[Extension]]) -> None:
+        raise TypeError(f"Unknown argument type: {type(extension)}")
+
+    @add_extension.register(Path)
+    @add_extension.register(str)
+    def _(self, lib_path: Union[Path, str]) -> None:
+        """Add custom operations from an extension.
+
+        Extends operation types available for creation by operations
+        loaded from prebuilt C++ library. Enables instantiation of custom
+        operations exposed in that library without direct use of
+        operation classes. Other types of extensions, e.g. conversion
+        extensions, if they are exposed in the library, are ignored.
+
+        In case if an extension operation type from the extension match
+        one of existing operations registered before (from the standard
+        OpenVINO opset or from another extension loaded earlier), a new
+        operation overrides an old operation.
+
+        Version of an operation is ignored: an operation with a given type and
+        a given version/opset will override operation with the same type but
+        different version/opset in the same NodeFactory instance.
+        Use separate libraries and NodeFactory instances to differentiate
+        versions/opsets.
+
+        :param      lib_path:  A path to the library with extension.
+        """
+        self.factory.add_extension(lib_path)
+
+    @add_extension.register(Extension)
+    @add_extension.register(list)
+    def _(self, extension: Union[Extension, List[Extension]]) -> None:
+        """Add custom operations from extension library.
+
+        Extends operation types available for creation by operations
+        loaded from prebuilt C++ library. Enables instantiation of custom
+        operations exposed in that library without direct use of
+        operation classes. Other types of extensions, e.g. conversion
+        extensions, if they are exposed in the library, are ignored.
+
+        In case if an extension operation type from a library match
+        one of existing operations registered before (from the standard
+        OpenVINO opset or from another extension loaded earlier), a new
+        operation overrides an old operation.
+
+        Version of an operation is ignored: an operation with a given type and
+        a given version/opset will override operation with the same type but
+        different version/opset in the same NodeFactory instance.
+        Use separate libraries and NodeFactory instances to differentiate
+        versions/opsets.
+
+        :param      extension:  A single Extension or list of Extensions.
+        """
+        self.factory.add_extension(extension)
+
+    @staticmethod
+    def _arguments_as_outputs(arguments: List[Union[Node, Output]]) -> List[Output]:
+        outputs = []
+        for argument in arguments:
+            if issubclass(type(argument), Output):
+                outputs.append(argument)
+            else:
+                outputs.extend(argument.outputs())
+        return outputs

intel_npu_acceleration_library/external/openvino/runtime/utils/reduction.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Iterable, Optional
+
+from openvino.runtime import Node
+
+
+def get_reduction_axes(node: Node, reduction_axes: Optional[Iterable[int]]) -> Iterable[int]:
+    """Get reduction axes if it is None and convert it to set if its type is different.
+
+    If reduction_axes is None we default to reduce all axes.
+
+    :param node: The node we fill reduction axes for.
+    :param reduction_axes: The collection of indices of axes to reduce. May be None.
+
+    returns: Set filled with indices of axes we want to reduce.
+    """
+    if reduction_axes is None:
+        reduction_axes = set(range(len(node.shape)))
+
+    if type(reduction_axes) is not set:
+        reduction_axes = set(reduction_axes)
+    return reduction_axes

intel_npu_acceleration_library/external/openvino/runtime/utils/types.py

@@ -0,0 +1,175 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""Functions related to converting between Python and numpy types and openvino types."""
+
+import logging
+from typing import List, Union, Optional
+
+import numpy as np
+
+from openvino.runtime.exceptions import OVTypeError
+from openvino.runtime import Node, Shape, Output, Type
+from openvino.runtime.op import Constant
+
+log = logging.getLogger(__name__)
+
+TensorShape = List[int]
+NumericData = Union[int, float, np.ndarray]
+NumericType = Union[type, np.dtype]
+ScalarData = Union[int, float]
+NodeInput = Union[Node, NumericData]
+
+openvino_to_numpy_types_map = [
+    (Type.boolean, bool),
+    (Type.boolean, np.bool_),
+    (Type.f16, np.float16),
+    (Type.f32, np.float32),
+    (Type.f64, np.float64),
+    (Type.i8, np.int8),
+    (Type.i16, np.int16),
+    (Type.i32, np.int32),
+    (Type.i64, np.int64),
+    (Type.u8, np.uint8),
+    (Type.u16, np.uint16),
+    (Type.u32, np.uint32),
+    (Type.u64, np.uint64),
+    (Type.bf16, np.uint16),
+    (Type.string, str),
+    (Type.string, np.str_),
+    (Type.string, bytes),
+    (Type.string, np.bytes_),
+]
+
+openvino_to_numpy_types_str_map = [
+    ("boolean", bool),
+    ("boolean", np.bool_),
+    ("f16", np.float16),
+    ("f32", np.float32),
+    ("f64", np.float64),
+    ("i8", np.int8),
+    ("i16", np.int16),
+    ("i32", np.int32),
+    ("i64", np.int64),
+    ("u8", np.uint8),
+    ("u16", np.uint16),
+    ("u32", np.uint32),
+    ("u64", np.uint64),
+    ("string", str),
+    ("string", np.str_),
+    ("string", bytes),
+    ("string", np.bytes_),
+]
+
+
+def get_element_type(data_type: NumericType) -> Type:
+    """Return an ngraph element type for a Python type or numpy.dtype."""
+    if data_type is int:
+        log.warning("Converting int type of undefined bitwidth to 32-bit ngraph integer.")
+        return Type.i32
+
+    if data_type is float:
+        log.warning("Converting float type of undefined bitwidth to 32-bit ngraph float.")
+        return Type.f32
+
+    ov_type = next(
+        (ov_type for (ov_type, np_type) in openvino_to_numpy_types_map if np_type == data_type),
+        None,
+    )
+    if ov_type:
+        return ov_type
+
+    raise OVTypeError("Unidentified data type %s", data_type)
+
+
+def get_element_type_str(data_type: NumericType) -> str:
+    """Return an ngraph element type string representation for a Python type or numpy dtype."""
+    if data_type is int:
+        log.warning("Converting int type of undefined bitwidth to 32-bit ngraph integer.")
+        return "i32"
+
+    if data_type is float:
+        log.warning("Converting float type of undefined bitwidth to 32-bit ngraph float.")
+        return "f32"
+
+    ov_type = next(
+        (ov_type for (ov_type, np_type) in openvino_to_numpy_types_str_map if np_type == data_type),
+        None,
+    )
+    if ov_type:
+        return ov_type
+
+    raise OVTypeError("Unidentified data type %s", data_type)
+
+
+def get_dtype(openvino_type: Type) -> np.dtype:
+    """Return a numpy.dtype for an openvino element type."""
+    np_type = next(
+        (np_type for (ov_type, np_type) in openvino_to_numpy_types_map if ov_type == openvino_type),
+        None,
+    )
+
+    if np_type:
+        return np.dtype(np_type)
+
+    raise OVTypeError("Unidentified data type %s", openvino_type)
+
+
+def get_numpy_ctype(openvino_type: Type) -> type:
+    """Return numpy ctype for an openvino element type."""
+    np_type = next(
+        (np_type for (ov_type, np_type) in openvino_to_numpy_types_map if ov_type == openvino_type),
+        None,
+    )
+
+    if np_type:
+        return np_type
+
+    raise OVTypeError("Unidentified data type %s", openvino_type)
+
+
+def get_ndarray(data: NumericData) -> np.ndarray:
+    """Wrap data into a numpy ndarray."""
+    if isinstance(data, np.ndarray):
+        return data  # type: ignore
+    return np.array(data)
+
+
+def get_shape(data: NumericData) -> TensorShape:
+    """Return a shape of NumericData."""
+    if isinstance(data, np.ndarray):
+        return data.shape  # type: ignore
+    if isinstance(data, list):
+        return [len(data)]  # type: ignore
+    return []
+
+
+def make_constant_node(value: NumericData, dtype: Union[NumericType, Type] = None, *, name: Optional[str] = None) -> Constant:
+    """Return an openvino Constant node with the specified value."""
+    ndarray = get_ndarray(value)
+    if dtype is not None:
+        element_type = get_element_type(dtype) if isinstance(dtype, (type, np.dtype)) else dtype
+    else:
+        element_type = get_element_type(ndarray.dtype)
+
+    const = Constant(element_type, Shape(ndarray.shape), ndarray.flatten().tolist())
+
+    if name:
+        const.friendly_name = name + "/" + const.friendly_name
+
+    return const
+
+
+def as_node(input_value: NodeInput, name: Optional[str] = None) -> Node:
+    """Return input values as nodes. Scalars will be converted to Constant nodes."""
+    if issubclass(type(input_value), Node):
+        return input_value
+    if issubclass(type(input_value), Output):
+        return input_value
+    return make_constant_node(input_value, name=name)
+
+
+def as_nodes(*input_values: NodeInput, name: Optional[str] = None) -> List[Node]:
+    """Return input values as nodes. Scalars will be converted to Constant nodes."""
+    return [as_node(input_value, name=name) for input_value in input_values]

intel_npu_acceleration_library/external/openvino/tools/__init__.py

@@ -0,0 +1,4 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)

intel_npu_acceleration_library/external/openvino/tools/benchmark/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+