bigdl-core-npu 2.6.0b20250114__cp310-cp310-win_amd64.whl

intel_npu_acceleration_library/external/openvino/runtime/opset14/ops.py

@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""Factory functions for ops added to openvino opset14."""
+from functools import partial
+
+from typing import Union, Optional, List
+
+from openvino.runtime import Node, Type
+from openvino.runtime.opset_utils import _get_node_factory
+from openvino.runtime.utils.types import TensorShape
+from openvino.runtime.utils.decorators import nameable_op
+from openvino.runtime.utils.types import NodeInput, as_node, as_nodes
+
+_get_node_factory_opset14 = partial(_get_node_factory, "opset14")
+
+
+# -------------------------------------------- ops ------------------------------------------------
+
+@nameable_op
+def convert_promote_types(
+    left_node: NodeInput,
+    right_node: NodeInput,
+    promote_unsafe: bool = False,
+    pytorch_scalar_promotion: bool = False,
+    u64_integer_promotion_target: Union[str, Type] = "f32",
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node performing conversion to common type based on promotion rules.
+
+    :param left_node: input node with type to be promoted to common one.
+    :param right_node: input node with type to be promoted to common one.
+    :param promote_unsafe: Bool attribute whether to allow promotions that might result in bit-widening, precision loss and undefined behaviors.
+    :param pytorch_scalar_promotion: Bool attribute whether to promote scalar input to type provided by non-scalar input when number format is matching.
+    :param u64_integer_promotion_target: Element type attribute to select promotion result when inputs are u64 and signed integer.
+    :param name: Optional name for the new output node.
+
+    :return: The new node performing ConvertPromoteTypes operation.
+    """
+    inputs = as_nodes(left_node, right_node, name=name)
+
+    attributes = {
+        "promote_unsafe": promote_unsafe,
+        "pytorch_scalar_promotion": pytorch_scalar_promotion,
+        "u64_integer_promotion_target": u64_integer_promotion_target,
+    }
+    return _get_node_factory_opset14().create("ConvertPromoteTypes", inputs, attributes)
+
+
+@nameable_op
+def inverse(
+    data: NodeInput,
+    adjoint: bool = False,
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node with inverse matrices of the input.
+
+    :param data: Tensor with matrices to invert. Last two dimensions must be of the same size.
+    :param adjoint: Whether to return adjoint instead of inverse matrices. Defaults to false.
+    :param name: Optional name for the new output node.
+
+    :return: The new node performing Inverse operation.
+    """
+    inputs = as_nodes(data, name=name)
+
+    attributes = {
+        "adjoint": adjoint,
+    }
+
+    return _get_node_factory_opset14().create("Inverse", inputs, attributes)
+
+
+@nameable_op
+def max_pool(
+    data: NodeInput,
+    strides: List[int],
+    dilations: List[int],
+    pads_begin: List[int],
+    pads_end: List[int],
+    kernel_shape: TensorShape,
+    rounding_type: str = "floor",
+    auto_pad: Optional[str] = None,
+    index_element_type: Optional[Union[str, Type]] = "i64",
+    axis: Optional[int] = 0,
+    name: Optional[str] = None,
+) -> Node:
+    """Perform max pooling operation and return both values and indices of the selected elements.
+
+    :param  data:                The node providing input data.
+    :param  strides:             The distance (in pixels) to slide the filter on the feature map
+                                 over the axes.
+    :param  dilations:           The dilation of filter elements(distance between elements).
+    :param  pads_begin:          The number of pixels to add at the beginning along each axis.
+    :param  pads_end:            The number of pixels to add at the end along each axis.
+    :param  kernel_shape:        The pooling operation kernel shape.
+    :param  rounding_type:       Determines used rounding schema when computing output shape.
+                                 Acceptable values are: ['floor', 'ceil', 'ceil_torch']. Defaults to 'floor'.
+    :param  auto_pad:            Determines how the padding is calculated. Acceptable values:
+                                 [None, 'same_upper', 'same_lower', 'valid']. Defaults to None.
+    :param  index_element_type:  The data type used for the indices output of this operator.
+                                 Defaults to i64.
+    :param  axis:                The first dimension in the data shape used to determine the maximum
+                                 returned index value. The value is the product of all dimensions
+                                 starting at the provided axis. Defaults to 0.
+    :param  name:                The optional name for the created output node.
+
+    :return:   The new node performing max pooling operation.
+    """
+    if auto_pad is None:
+        auto_pad = "explicit"
+    return _get_node_factory_opset14().create(
+        "MaxPool",
+        [as_node(data, name=name)],
+        {
+            "strides": strides,
+            "dilations": dilations,
+            "pads_begin": pads_begin,
+            "pads_end": pads_end,
+            "kernel": kernel_shape,
+            "rounding_type": rounding_type.upper(),
+            "auto_pad": auto_pad.upper(),
+            "index_element_type": index_element_type,
+            "axis": axis,
+        },
+    )
+
+
+@nameable_op
+def avg_pool(
+    data_batch: NodeInput,
+    strides: List[int],
+    pads_begin: TensorShape,
+    pads_end: TensorShape,
+    kernel_shape: TensorShape,
+    exclude_pad: bool,
+    rounding_type: str = "floor",
+    auto_pad: Optional[str] = None,
+    name: Optional[str] = None,
+) -> Node:
+    """Return average pooling node.
+
+    :param data_batch:      The input node providing data.
+    :param strides:         The window movement strides.
+    :param pads_begin:      The number of pixels to add at the beginning along each axis.
+    :param pads_end:        The number of pixels to add at the end along each axis.
+    :param kernel_shape:    The pooling window shape.
+    :param exclude_pad:     Whether or not to include zero padding in average computations.
+    :param rounding_type:   Determines used rounding schema when computing output shape. Acceptable
+                            values are: ['floor', 'ceil', 'ceil_torch']. Defaults to 'floor'.
+    :param auto_pad:        Determines how the padding is calculated. Acceptable values:
+                            [None, 'same_upper', 'same_lower', 'valid']. Defaults to None.
+    :param name:            Optional name for the new output node.
+
+    :return: New node with AvgPool operation applied on its data.
+    """
+    if auto_pad is None:
+        auto_pad = "explicit"
+    return _get_node_factory_opset14().create(
+        "AvgPool",
+        [as_node(data_batch, name=name)],
+        {
+            "strides": strides,
+            "pads_begin": pads_begin,
+            "pads_end": pads_end,
+            "kernel": kernel_shape,
+            "exclude-pad": exclude_pad,
+            "rounding_type": rounding_type.upper(),
+            "auto_pad": auto_pad.upper(),
+        },
+    )

intel_npu_acceleration_library/external/openvino/runtime/opset15/__init__.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# Inlcudes new operators added in Opset15
+
+# TODO (ticket 138273): Add previous opset operators at the end of opset15 development
+from openvino.runtime.opset1.ops import parameter
+from openvino.runtime.opset15.ops import col2im
+from openvino.runtime.opset15.ops import embedding_bag_offsets
+from openvino.runtime.opset15.ops import embedding_bag_packed
+from openvino.runtime.opset15.ops import scatter_nd_update
+from openvino.runtime.opset15.ops import roi_align_rotated
+from openvino.runtime.opset15.ops import string_tensor_pack
+from openvino.runtime.opset15.ops import string_tensor_unpack
+from openvino.runtime.opset15.ops import bitwise_left_shift
+from openvino.runtime.opset15.ops import bitwise_right_shift

intel_npu_acceleration_library/external/openvino/runtime/opset15/ops.py

@@ -0,0 +1,276 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""Factory functions for ops added to openvino opset15."""
+from functools import partial
+from typing import List, Literal, Optional
+
+import numpy as np
+from openvino.runtime import Node, Type
+from openvino.runtime.opset1 import convert_like
+from openvino.runtime.opset14 import constant
+from openvino.runtime.opset_utils import _get_node_factory
+from openvino.runtime.utils.decorators import binary_op, nameable_op
+from openvino.runtime.utils.types import NodeInput, as_nodes
+
+_get_node_factory_opset15 = partial(_get_node_factory, "opset15")
+
+# -------------------------------------------- ops ------------------------------------------------
+
+
+@nameable_op
+def scatter_nd_update(
+    data: NodeInput,
+    indices: NodeInput,
+    updates: NodeInput,
+    reduction: Optional[Literal["none", "sum", "sub", "prod", "min", "max"]] = None,
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs ScatterNDUpdate.
+
+    :param data: Node input representing the tensor to be updated.
+    :param indices: Node input representing the indices at which updates will be applied.
+    :param updates: Node input representing the updates to be applied.
+    :param reduction: The type of operation to perform on the inputs. One of "none", "sum",
+                      "sub", "prod", "min", "max".
+    :param name: Optional name for the output node.
+    :return: New node performing the ScatterNDUpdate.
+    """
+    inputs = as_nodes(data, indices, updates, name=name)
+    attributes = {}
+    if reduction:
+        attributes["reduction"] = reduction
+    return _get_node_factory_opset15().create("ScatterNDUpdate", inputs, attributes)
+
+
+@nameable_op
+def col2im(
+    data: NodeInput,
+    output_size: NodeInput,
+    kernel_size: NodeInput,
+    strides: Optional[List[int]] = None,
+    dilations: Optional[List[int]] = None,
+    pads_begin: Optional[List[int]] = None,
+    pads_end: Optional[List[int]] = None,
+    name: Optional[str] = None,
+) -> Node:
+    """Perform data movement operation which combines sliding blocks into an image tensor.
+
+    :param  data:                The node providing input data.
+    :param  output_size:         Shape of the spatial dimensions of the output image.
+    :param  kernel_size:         Size of the sliding blocks.
+    :param  strides:             Stride on the sliding blocks in the input spatial dimensions. Defaults to [1, 1].
+    :param  dilations:           The dilation of filter elements (distance between elements). Defaults to [1, 1].
+    :param  pads_begin:          The number of pixels added at the beginning along each axis. Defaults to [0, 0].
+    :param  pads_end:            The number of pixels added at the end along each axis. Defaults to [0, 0].
+    :param  name:                The optional name for the created output node.
+
+    :return:   The new node performing Col2Im operation.
+    """
+    if strides is None:
+        strides = [1, 1]
+    if dilations is None:
+        dilations = [1, 1]
+    if pads_begin is None:
+        pads_begin = [0, 0]
+    if pads_end is None:
+        pads_end = [0, 0]
+    return _get_node_factory_opset15().create(
+        "Col2Im",
+        as_nodes(data, output_size, kernel_size, name=name),
+        {
+            "strides": strides,
+            "dilations": dilations,
+            "pads_begin": pads_begin,
+            "pads_end": pads_end,
+        },
+    )
+
+
+@nameable_op
+def embedding_bag_offsets(
+    emb_table: NodeInput,
+    indices: NodeInput,
+    offsets: NodeInput,
+    default_index: Optional[NodeInput] = None,
+    per_sample_weights: Optional[NodeInput] = None,
+    reduction: Literal["sum", "mean"] = "sum",
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs sums or means of bags of embeddings without the intermediate embeddings.
+
+    :param emb_table: Tensor containing the embedding lookup table.
+    :param indices: 1D Tensor with indices.
+    :param offsets: 1D Tensor containing the starting index positions of each bag in indices.
+    :param per_sample_weights: Tensor with weights for each sample.
+    :param default_index: Scalar containing default index in embedding table to fill empty bags.
+                          If unset or set to -1, empty bags will be filled with 0.
+                          Reverse indexing using negative indices is not supported.
+    :param reduction: String to select algorithm used to perform reduction of elements in bag.
+    :param name: Optional name for output node.
+    :return: The new node performing EmbeddingBagOffsets operation.
+    """
+    inputs = [emb_table, indices, offsets]
+    if default_index is not None:
+        inputs.append(default_index)
+    elif per_sample_weights is not None:
+        inputs.append(convert_like(constant(np.array(-1, np.int32)), inputs[1]))
+    if per_sample_weights is not None:
+        inputs.append(per_sample_weights)
+
+    return _get_node_factory_opset15().create("EmbeddingBagOffsets", as_nodes(*inputs, name=name), {"reduction": reduction})
+
+
+@nameable_op
+def embedding_bag_packed(
+    emb_table: NodeInput,
+    indices: NodeInput,
+    per_sample_weights: Optional[NodeInput] = None,
+    reduction: Literal["sum", "mean"] = "sum",
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs sums or means of "bags" of embeddings, without the intermediate embeddings.
+
+    :param emb_table: Tensor containing the embedding lookup table.
+    :param indices: 2D Tensor of shape [batch, indices_per_bag] with indices.
+    :param per_sample_weights: Tensor of weights to be multiplied with embedding table with same shape as indices.
+    :param reduction: Operator to perform reduction of elements in bag.
+    :param name: Optional name for output node.
+    :return: The new node performing EmbeddingBagPacked operation.
+    """
+    inputs = [emb_table, indices]
+    if per_sample_weights is not None:
+        inputs.append(per_sample_weights)
+
+    return _get_node_factory_opset15().create("EmbeddingBagPacked", as_nodes(*inputs, name=name), {"reduction": reduction})
+
+
+@nameable_op
+def roi_align_rotated(
+    data: NodeInput,
+    rois: NodeInput,
+    batch_indices: NodeInput,
+    pooled_h: int,
+    pooled_w: int,
+    sampling_ratio: int,
+    spatial_scale: float,
+    clockwise_mode: bool,
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs ROIAlignRotated operation.
+
+    :param data: Input data.
+    :param rois: RoIs (Regions of Interest) to pool over.
+    :param batch_indices: Tensor with each element denoting the index of
+                          the corresponding image in the batch.
+    :param pooled_h: Height of the ROI output feature map.
+    :param pooled_w: Width of the ROI output feature map.
+    :param sampling_ratio: Number of bins over height and width to use to calculate
+                           each output feature map element.
+    :param spatial_scale: Multiplicative spatial scale factor to translate ROI coordinates.
+    :param clockwise_mode:  If true, rotation angle is interpreted as clockwise,
+                            otherwise as counterclockwise
+    :param name: The optional name for the output node
+
+    :return: The new node which performs ROIAlignRotated
+    """
+    return _get_node_factory_opset15().create(
+        "ROIAlignRotated",
+        as_nodes(data, rois, batch_indices, name=name),
+        {
+            "pooled_h": pooled_h,
+            "pooled_w": pooled_w,
+            "sampling_ratio": sampling_ratio,
+            "spatial_scale": spatial_scale,
+            "clockwise_mode": clockwise_mode,
+        },
+    )
+
+
+@nameable_op
+def string_tensor_unpack(
+    data: NodeInput,
+    name: Optional[str] = None,
+) -> Node:
+    """Perform an operation which unpacks a batch of strings into three tensors.
+
+    :param data: The node providing input data.
+
+    :return: The new node performing StringTensorUnpack operation.
+    """
+    return _get_node_factory_opset15().create(
+        "StringTensorUnpack",
+        as_nodes(data, name=name)
+    )
+
+
+@nameable_op
+def string_tensor_pack(
+    begins: NodeInput,
+    ends: NodeInput,
+    symbols: NodeInput,
+    name: Optional[str] = None,
+) -> Node:
+    """Perform an operation which packs a concatenated batch of strings into a batched string tensor.
+
+    :param begins: ND tensor of non-negative integer numbers containing indices of each string's beginnings.
+    :param ends: ND tensor of non-negative integer numbers containing indices of each string's endings.
+    :param symbols: 1D tensor of concatenated strings data encoded in utf-8 bytes.
+
+    :return: The new node performing StringTensorPack operation.
+    """
+    return _get_node_factory_opset15().create(
+        "StringTensorPack",
+        as_nodes(begins, ends, symbols, name=name)
+    )
+
+
+@binary_op
+def bitwise_left_shift(
+    arg0: NodeInput,
+    arg1: NodeInput,
+    auto_broadcast: str = "NUMPY",
+    name: Optional[str] = None,
+) -> Node:
+    """Return node which performs BitwiseLeftShift operation on input nodes element-wise.
+
+    :param arg0: Node with data to be shifted.
+    :param arg1: Node with number of shifts.
+    :param auto_broadcast: The type of broadcasting specifies rules used for auto-broadcasting of input tensors.
+                           Defaults to “NUMPY”.
+
+    :return: The new node performing BitwiseLeftShift operation.
+    """
+    return _get_node_factory_opset15().create(
+        "BitwiseLeftShift",
+        as_nodes(arg0, arg1, name=name),
+        {
+            "auto_broadcast": auto_broadcast.upper(),
+        },
+    )
+
+
+@binary_op
+def bitwise_right_shift(
+    arg0: NodeInput,
+    arg1: NodeInput,
+    auto_broadcast: str = "NUMPY",
+    name: Optional[str] = None,
+) -> Node:
+    """Return node which performs BitwiseRightShift operation on input nodes element-wise.
+
+    :param arg0: Tensor with data to be shifted.
+    :param arg1: Tensor with number of shifts.
+    :param auto_broadcast: The type of broadcasting specifies rules used for auto-broadcasting of input tensors.
+                           Defaults to “NUMPY”.
+
+    :return: The new node performing BitwiseRightShift operation.
+    """
+    return _get_node_factory_opset15().create(
+        "BitwiseRightShift",
+        as_nodes(arg0, arg1, name=name),
+        {
+            "auto_broadcast": auto_broadcast.upper(),
+        },
+    )

intel_npu_acceleration_library/external/openvino/runtime/opset2/__init__.py

@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from openvino.runtime.opset1.ops import absolute
+from openvino.runtime.opset1.ops import absolute as abs
+from openvino.runtime.opset1.ops import acos
+from openvino.runtime.opset1.ops import add
+from openvino.runtime.opset1.ops import asin
+from openvino.runtime.opset1.ops import atan
+from openvino.runtime.opset1.ops import avg_pool
+from openvino.runtime.opset1.ops import batch_norm_inference
+from openvino.runtime.opset2.ops import batch_to_space
+from openvino.runtime.opset1.ops import binary_convolution
+from openvino.runtime.opset1.ops import broadcast
+from openvino.runtime.opset1.ops import ceiling
+from openvino.runtime.opset1.ops import ceiling as ceil
+from openvino.runtime.opset1.ops import clamp
+from openvino.runtime.opset1.ops import concat
+from openvino.runtime.opset1.ops import constant
+from openvino.runtime.opset1.ops import convert
+from openvino.runtime.opset1.ops import convert_like
+from openvino.runtime.opset1.ops import convolution
+from openvino.runtime.opset1.ops import convolution_backprop_data
+from openvino.runtime.opset1.ops import cos
+from openvino.runtime.opset1.ops import cosh
+from openvino.runtime.opset1.ops import ctc_greedy_decoder
+from openvino.runtime.opset1.ops import deformable_convolution
+from openvino.runtime.opset1.ops import deformable_psroi_pooling
+from openvino.runtime.opset1.ops import depth_to_space
+from openvino.runtime.opset1.ops import detection_output
+from openvino.runtime.opset1.ops import divide
+from openvino.runtime.opset1.ops import elu
+from openvino.runtime.opset1.ops import equal
+from openvino.runtime.opset1.ops import erf
+from openvino.runtime.opset1.ops import exp
+from openvino.runtime.opset1.ops import fake_quantize
+from openvino.runtime.opset1.ops import floor
+from openvino.runtime.opset1.ops import floor_mod
+from openvino.runtime.opset1.ops import gather
+from openvino.runtime.opset1.ops import gather_tree
+from openvino.runtime.opset2.ops import gelu
+from openvino.runtime.opset1.ops import greater
+from openvino.runtime.opset1.ops import greater_equal
+from openvino.runtime.opset1.ops import grn
+from openvino.runtime.opset1.ops import group_convolution
+from openvino.runtime.opset1.ops import group_convolution_backprop_data
+from openvino.runtime.opset1.ops import hard_sigmoid
+from openvino.runtime.opset1.ops import interpolate
+from openvino.runtime.opset1.ops import less
+from openvino.runtime.opset1.ops import less_equal
+from openvino.runtime.opset1.ops import log
+from openvino.runtime.opset1.ops import logical_and
+from openvino.runtime.opset1.ops import logical_not
+from openvino.runtime.opset1.ops import logical_or
+from openvino.runtime.opset1.ops import logical_xor
+from openvino.runtime.opset1.ops import lrn
+from openvino.runtime.opset1.ops import lstm_cell
+from openvino.runtime.opset1.ops import lstm_sequence
+from openvino.runtime.opset1.ops import matmul
+from openvino.runtime.opset1.ops import max_pool
+from openvino.runtime.opset1.ops import maximum
+from openvino.runtime.opset1.ops import minimum
+from openvino.runtime.opset1.ops import mod
+from openvino.runtime.opset1.ops import multiply
+from openvino.runtime.opset2.ops import mvn
+from openvino.runtime.opset1.ops import negative
+from openvino.runtime.opset1.ops import non_max_suppression
+from openvino.runtime.opset1.ops import normalize_l2
+from openvino.runtime.opset1.ops import not_equal
+from openvino.runtime.opset1.ops import one_hot
+from openvino.runtime.opset1.ops import pad
+from openvino.runtime.opset1.ops import parameter
+from openvino.runtime.opset1.ops import power
+from openvino.runtime.opset1.ops import prelu
+from openvino.runtime.opset1.ops import prior_box
+from openvino.runtime.opset1.ops import prior_box_clustered
+from openvino.runtime.opset1.ops import psroi_pooling
+from openvino.runtime.opset1.ops import proposal
+from openvino.runtime.opset1.ops import range
+from openvino.runtime.opset1.ops import reduce_logical_and
+from openvino.runtime.opset1.ops import reduce_logical_or
+from openvino.runtime.opset1.ops import reduce_max
+from openvino.runtime.opset1.ops import reduce_mean
+from openvino.runtime.opset1.ops import reduce_min
+from openvino.runtime.opset1.ops import reduce_prod
+from openvino.runtime.opset1.ops import reduce_sum
+from openvino.runtime.opset1.ops import region_yolo
+from openvino.runtime.opset2.ops import reorg_yolo
+from openvino.runtime.opset1.ops import relu
+from openvino.runtime.opset1.ops import reshape
+from openvino.runtime.opset1.ops import result
+from openvino.runtime.opset1.ops import reverse_sequence
+from openvino.runtime.opset2.ops import roi_pooling
+from openvino.runtime.opset1.ops import select
+from openvino.runtime.opset1.ops import selu
+from openvino.runtime.opset1.ops import shape_of
+from openvino.runtime.opset1.ops import sigmoid
+from openvino.runtime.opset1.ops import sign
+from openvino.runtime.opset1.ops import sin
+from openvino.runtime.opset1.ops import sinh
+from openvino.runtime.opset1.ops import softmax
+from openvino.runtime.opset2.ops import space_to_batch
+from openvino.runtime.opset1.ops import space_to_depth
+from openvino.runtime.opset1.ops import split
+from openvino.runtime.opset1.ops import sqrt
+from openvino.runtime.opset1.ops import squared_difference
+from openvino.runtime.opset1.ops import squeeze
+from openvino.runtime.opset1.ops import strided_slice
+from openvino.runtime.opset1.ops import subtract
+from openvino.runtime.opset1.ops import tan
+from openvino.runtime.opset1.ops import tanh
+from openvino.runtime.opset1.ops import tensor_iterator
+from openvino.runtime.opset1.ops import tile
+from openvino.runtime.opset1.ops import topk
+from openvino.runtime.opset1.ops import transpose
+from openvino.runtime.opset1.ops import unsqueeze
+from openvino.runtime.opset1.ops import variadic_split