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

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

@@ -0,0 +1,215 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import numpy as np
+
+"""Factory functions for all openvino ops."""
+from typing import Optional, Union
+
+from functools import partial, singledispatch
+
+from openvino.runtime import Node, Type, PartialShape, Output, Shape
+from openvino.runtime.op import assign, Constant, Parameter
+from openvino.runtime.op import read_value as _read_value
+from openvino.runtime.op.util import VariableInfo, Variable
+from openvino.runtime.opset_utils import _get_node_factory
+from openvino.runtime.utils.decorators import nameable_op, overloading
+from openvino.runtime.utils.types import (
+    NodeInput,
+    NumericType,
+    TensorShape,
+    as_node,
+    as_nodes,
+    get_element_type,
+)
+
+_get_node_factory_opset6 = partial(_get_node_factory, "opset6")
+
+# -------------------------------------------- ops ------------------------------------------------
+
+
+@nameable_op
+def ctc_greedy_decoder_seq_len(
+    data: NodeInput,
+    sequence_length: NodeInput,
+    blank_index: Optional[NodeInput] = None,
+    merge_repeated: bool = True,
+    classes_index_type: str = "i32",
+    sequence_length_type: str = "i32",
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs CTCGreedyDecoderSeqLen.
+
+    :param data:            The input 3D tensor. Shape: [batch_size, seq_length, num_classes]
+    :param sequence_length: Input 1D tensor with sequence length. Shape: [batch_size]
+    :param blank_index:     Scalar or 1D tensor with specifies the class index to use for the blank class.
+                            Optional parameter. Default value is num_classes-1.
+    :return:                The new node which performs CTCGreedyDecoderSeqLen.
+    """
+    if blank_index is not None:
+        inputs = as_nodes(data, sequence_length, blank_index, name=name)
+    else:
+        inputs = as_nodes(data, sequence_length, name=name)
+
+    attributes = {
+        "merge_repeated": merge_repeated,
+        "classes_index_type": classes_index_type,
+        "sequence_length_type": sequence_length_type,
+    }
+
+    return _get_node_factory_opset6().create("CTCGreedyDecoderSeqLen", inputs, attributes)
+
+
+@nameable_op
+def gather_elements(
+    data: NodeInput,
+    indices: NodeInput,
+    axis: Optional[int] = 0,
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs GatherElements.
+
+    :param data:       N-D tensor with data for gathering
+    :param indices:    N-D tensor with indices by which data is gathered
+    :param axis:       axis along which elements are gathered
+    :return:           The new node which performs GatherElements
+    """
+    inputs = as_nodes(data, indices, name=name)
+
+    attributes = {
+        "axis": axis,
+    }
+
+    return _get_node_factory_opset6().create("GatherElements", inputs, attributes)
+
+
+@nameable_op
+def mvn(
+    data: Node,
+    axes: Node,
+    normalize_variance: bool,
+    eps: float,
+    eps_mode: str,
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs MeanVarianceNormalization (MVN).
+
+    :param data: The node with data tensor.
+    :param axes: The node with axes to reduce on.
+    :param normalize_variance: Denotes whether to perform variance normalization.
+    :param eps: The number added to the variance to avoid division by zero
+               when normalizing the value. Scalar value.
+    :param eps_mode: how eps is applied (`inside_sqrt` or `outside_sqrt`)
+    :param name: Optional output node name.
+    :return: The new node performing a MVN operation on input tensor.
+    """
+    inputs = as_nodes(data, axes, name=name)
+
+    attributes = {
+        "normalize_variance": normalize_variance,
+        "eps": eps,
+        "eps_mode": eps_mode,
+    }
+
+    return _get_node_factory_opset6().create("MVN", inputs, attributes)
+
+
+@overloading(Union[Node, Output, int, float, np.ndarray], str, Optional[Union[type, np.dtype, Type, str]],
+             Optional[Union[TensorShape, Shape, PartialShape]], Optional[str])
+@nameable_op
+def read_value(init_value: Union[Node, Output, int, float, np.ndarray],
+               variable_id: str,
+               variable_type: Optional[Union[type, np.dtype, Type, str]] = None,
+               variable_shape: Optional[Union[TensorShape, Shape, PartialShape]] = None,
+               name: Optional[str] = None) -> Node:
+    """Return a node which produces the Assign operation.
+
+    :param init_value:   Node producing a value to be returned instead of an unassigned variable.
+    :param variable_id:  Id of a variable to be read.
+    :param variable_type:   Optional type to be set into Variable.
+    :param variable_shape:  Optional shape to be set into Variable.
+    :param name:         Optional name for output node.
+    :return: ReadValue node
+    """
+    info = VariableInfo()
+    info.variable_id = variable_id
+
+    if variable_type is not None:
+        if not isinstance(variable_type, Type) and not isinstance(variable_type, str):
+            info.data_type = get_element_type(variable_type)
+        else:
+            info.data_type = variable_type
+    else:
+        info.data_type = Type.dynamic
+
+    if variable_shape is not None:
+        info.data_shape = PartialShape(variable_shape)
+    else:
+        info.data_shape = PartialShape.dynamic()
+
+    var_from_info = Variable(info)
+    return _read_value(new_value=as_node(init_value, name=name), variable=var_from_info)
+
+
+@overloading(str, Optional[Union[type, np.dtype, Type, str]], Optional[Union[TensorShape, Shape, PartialShape]], Optional[str])  # type: ignore
+@nameable_op
+def read_value(variable_id: str,  # noqa: F811
+               variable_type: Optional[Union[type, np.dtype, Type, str]] = None,
+               variable_shape: Optional[Union[TensorShape, Shape, PartialShape]] = None,
+               name: Optional[str] = None) -> Node:
+    """Return a node which produces the Assign operation.
+
+    :param variable_id:  Id of a variable to be read.
+    :param variable_type:   Optional type to be set into Variable.
+    :param variable_shape:  Optional shape to be set into Variable.
+    :param name:         Optional name for output node.
+    :return: ReadValue node
+    """
+    info = VariableInfo()
+    info.variable_id = variable_id
+
+    if variable_type is not None:
+        if not isinstance(variable_type, Type) and not isinstance(variable_type, str):
+            info.data_type = get_element_type(variable_type)
+        else:
+            info.data_type = variable_type
+    else:
+        info.data_type = Type.dynamic
+
+    if variable_shape is not None:
+        info.data_shape = PartialShape(variable_shape)
+    else:
+        info.data_shape = PartialShape.dynamic()
+
+    var_from_info = Variable(info)
+
+    return _read_value(var_from_info)
+
+
+@overloading(Variable, Optional[str])    # type: ignore
+@nameable_op
+def read_value(ov_variable: Variable,  # noqa: F811
+               name: Optional[str] = None) -> Node:
+    """Return a node which produces the Assign operation.
+
+    :param ov_variable:  Variable to be read.
+    :param name:         Optional name for output node.
+    :return: ReadValue node
+    """
+    return _read_value(ov_variable)
+
+
+@overloading(Union[Node, Output, int, float, np.ndarray], Variable, Optional[str])  # type: ignore
+@nameable_op
+def read_value(init_value: Union[Node, Output, int, float, np.ndarray],  # noqa: F811
+               ov_variable: Variable,
+               name: Optional[str] = None) -> Node:
+    """Return a node which produces the Assign operation.
+
+    :param init_value:   Optional node producing a value to be returned instead of an unassigned variable.
+    :param ov_variable:  Variable to be read.
+    :param name:         Optional name for output node.
+    :return: ReadValue node
+    """
+    return _read_value(as_node(init_value, name=name), ov_variable)

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

@@ -0,0 +1,158 @@
+# -*- 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.opset4.ops import acosh
+from openvino.runtime.opset1.ops import add
+from openvino.runtime.opset1.ops import asin
+from openvino.runtime.opset4.ops import asinh
+from openvino.runtime.opset6.ops import assign
+from openvino.runtime.opset1.ops import atan
+from openvino.runtime.opset4.ops import atanh
+from openvino.runtime.opset1.ops import avg_pool
+from openvino.runtime.opset5.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.opset3.ops import broadcast
+from openvino.runtime.opset3.ops import bucketize
+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.opset6.ops import ctc_greedy_decoder_seq_len
+from openvino.runtime.opset4.ops import ctc_loss
+from openvino.runtime.opset3.ops import cum_sum
+from openvino.runtime.opset3.ops import cum_sum as cumsum
+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.opset7.ops import dft
+from openvino.runtime.opset1.ops import divide
+from openvino.runtime.opset7.ops import einsum
+from openvino.runtime.opset1.ops import elu
+from openvino.runtime.opset3.ops import embedding_bag_offsets_sum
+from openvino.runtime.opset3.ops import embedding_bag_packed_sum
+from openvino.runtime.opset3.ops import embedding_segments_sum
+from openvino.runtime.opset3.ops import extract_image_patches
+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.opset7.ops import gather
+from openvino.runtime.opset6.ops import gather_elements
+from openvino.runtime.opset5.ops import gather_nd
+from openvino.runtime.opset1.ops import gather_tree
+from openvino.runtime.opset7.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.opset3.ops import gru_cell
+from openvino.runtime.opset5.ops import gru_sequence
+from openvino.runtime.opset1.ops import hard_sigmoid
+from openvino.runtime.opset5.ops import hsigmoid
+from openvino.runtime.opset4.ops import hswish
+from openvino.runtime.opset7.ops import idft
+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.opset5.ops import log_softmax
+from openvino.runtime.opset5.ops import loop
+from openvino.runtime.opset1.ops import lrn
+from openvino.runtime.opset4.ops import lstm_cell
+from openvino.runtime.opset5.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.opset4.ops import mish
+from openvino.runtime.opset1.ops import mod
+from openvino.runtime.opset1.ops import multiply
+from openvino.runtime.opset6.ops import mvn
+from openvino.runtime.opset1.ops import negative
+from openvino.runtime.opset5.ops import non_max_suppression
+from openvino.runtime.opset3.ops import non_zero
+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.opset4.ops import proposal
+from openvino.runtime.opset1.ops import range
+from openvino.runtime.opset6.ops import read_value
+from openvino.runtime.opset4.ops import reduce_l1
+from openvino.runtime.opset4.ops import reduce_l2
+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.opset3.ops import rnn_cell
+from openvino.runtime.opset5.ops import rnn_sequence
+from openvino.runtime.opset3.ops import roi_align
+from openvino.runtime.opset2.ops import roi_pooling
+from openvino.runtime.opset7.ops import roll
+from openvino.runtime.opset5.ops import round
+from openvino.runtime.opset3.ops import scatter_elements_update
+from openvino.runtime.opset4.ops import scatter_nd_update
+from openvino.runtime.opset3.ops import scatter_update
+from openvino.runtime.opset1.ops import select
+from openvino.runtime.opset1.ops import selu
+from openvino.runtime.opset3.ops import shape_of
+from openvino.runtime.opset3.ops import shuffle_channels
+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.opset4.ops import softplus
+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.opset4.ops import swish
+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.opset3.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

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

@@ -0,0 +1,169 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""Factory functions for all openvino ops."""
+from functools import partial
+from typing import Callable, Iterable, List, Optional, Set, Union
+
+import numpy as np
+from openvino.runtime import Node, Shape
+from openvino.runtime.op import Constant, Parameter
+from openvino.runtime.opset_utils import _get_node_factory
+from openvino.runtime.utils.decorators import binary_op, nameable_op, unary_op
+from openvino.runtime.utils.input_validation import (
+    assert_list_of_ints,
+    check_valid_attributes,
+    is_non_negative_value,
+    is_positive_value,
+)
+from openvino.runtime.utils.node_factory import NodeFactory
+from openvino.runtime.utils.types import (
+    NodeInput,
+    NumericData,
+    NumericType,
+    ScalarData,
+    TensorShape,
+    as_node,
+    as_nodes,
+    get_dtype,
+    get_element_type,
+    get_element_type_str,
+    make_constant_node,
+)
+
+_get_node_factory_opset7 = partial(_get_node_factory, "opset7")
+
+
+# -------------------------------------------- ops ------------------------------------------------
+
+
+@nameable_op
+def einsum(
+    inputs: List[Node],
+    equation: str,
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs Einsum operation.
+
+    :param inputs: The list of input nodes
+    :param equation: Einsum equation
+    :param name: Optional output node name.
+    :return: The new node performing Einsum operation on the inputs
+    """
+    attributes = {
+        "equation": equation,
+    }
+
+    return _get_node_factory_opset7().create("Einsum", as_nodes(*inputs, name=name), attributes)
+
+
+@nameable_op
+def gelu(
+    data: Node,
+    approximation_mode: str,
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs Gelu activation function.
+
+    :param data: The node with data tensor.
+    :param approximation_mode: defines which approximation to use ('tanh' or 'erf')
+    :param name: Optional output node name.
+    :return: The new node performing a Gelu activation with the input tensor.
+    """
+    inputs = as_nodes(data, name=name)
+
+    attributes = {
+        "approximation_mode": approximation_mode,
+    }
+
+    return _get_node_factory_opset7().create("Gelu", inputs, attributes)
+
+
+@nameable_op
+def roll(
+    data: NodeInput,
+    shift: NodeInput,
+    axes: NodeInput,
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs Roll operation.
+
+    :param data: The node with data tensor.
+    :param shift: The node with the tensor with numbers of places by which elements are shifted.
+    :param axes: The node with the tensor with axes along which elements are shifted.
+    :param name: Optional output node name.
+    :return: The new node performing a Roll operation on the input tensor.
+    """
+    inputs = as_nodes(data, shift, axes, name=name)
+
+    return _get_node_factory_opset7().create("Roll", inputs)
+
+
+@nameable_op
+def gather(
+    data: NodeInput,
+    indices: NodeInput,
+    axis: NodeInput,
+    batch_dims: Optional[int] = 0,
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs Gather.
+
+    :param data:         N-D tensor with data for gathering
+    :param indices:      N-D tensor with indices by which data is gathered
+    :param axis:         axis along which elements are gathered
+    :param batch_dims:   number of batch dimensions
+    :param name:         Optional output node name.
+    :return:             The new node which performs Gather
+    """
+    inputs = as_nodes(data, indices, axis, name=name)
+    attributes = {
+        "batch_dims": batch_dims,
+    }
+    return _get_node_factory_opset7().create("Gather", inputs, attributes)
+
+
+def dft(
+    data: NodeInput,
+    axes: NodeInput,
+    signal_size: Optional[NodeInput] = None,
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs DFT operation.
+
+    :param data: Tensor with transformed data.
+    :param axes: Tensor with axes to transform.
+    :param signal_size: Tensor specifying signal size with respect to axes from the input 'axes'.
+    :param name: Optional output node name.
+    :return: The new node which performs DFT operation on the input data tensor.
+    """
+    if signal_size is None:
+        inputs = as_nodes(data, axes, name=name)
+    else:
+        inputs = as_nodes(data, axes, signal_size, name=name)
+
+    return _get_node_factory_opset7().create("DFT", inputs)
+
+
+@nameable_op
+def idft(
+    data: NodeInput,
+    axes: NodeInput,
+    signal_size: Optional[NodeInput] = None,
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs IDFT operation.
+
+    :param data: Tensor with transformed data.
+    :param axes: Tensor with axes to transform.
+    :param signal_size: Tensor specifying signal size with respect to axes from the input 'axes'.
+    :param name: Optional output node name.
+    :return: The new node which performs IDFT operation on the input data tensor.
+    """
+    if signal_size is None:
+        inputs = as_nodes(data, axes, name=name)
+    else:
+        inputs = as_nodes(data, axes, signal_size, name=name)
+
+    return _get_node_factory_opset7().create("IDFT", inputs)