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

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

@@ -0,0 +1,175 @@
+# -*- 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.opset8.ops import adaptive_avg_pool
+from openvino.runtime.opset8.ops import adaptive_max_pool
+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.opset8.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.opset8.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.opset9.ops import eye
+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.opset8.ops import gather
+from openvino.runtime.opset6.ops import gather_elements
+from openvino.runtime.opset8.ops import gather_nd
+from openvino.runtime.opset1.ops import gather_tree
+from openvino.runtime.opset7.ops import gelu
+from openvino.runtime.opset9.ops import generate_proposals
+from openvino.runtime.opset1.ops import greater
+from openvino.runtime.opset1.ops import greater_equal
+from openvino.runtime.opset9.ops import grid_sample
+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.opset8.ops import if_op
+from openvino.runtime.opset1.ops import interpolate
+from openvino.runtime.opset9.ops import irdft
+from openvino.runtime.opset8.ops import i420_to_bgr
+from openvino.runtime.opset8.ops import i420_to_rgb
+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.opset8.ops import matrix_nms
+from openvino.runtime.opset8.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.opset9.ops import multiclass_nms
+from openvino.runtime.opset1.ops import multiply
+from openvino.runtime.opset6.ops import mvn
+from openvino.runtime.opset1.ops import negative
+from openvino.runtime.opset9.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.opset8.ops import nv12_to_bgr
+from openvino.runtime.opset8.ops import nv12_to_rgb
+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.opset8.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.opset8.ops import random_uniform
+from openvino.runtime.opset9.ops import rdft
+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.opset9.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.opset8.ops import slice
+from openvino.runtime.opset8.ops import softmax
+from openvino.runtime.opset4.ops import softplus
+from openvino.runtime.opset9.ops import softsign
+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/opset9/ops.py

@@ -0,0 +1,341 @@
+# -*- 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 Optional
+
+import numpy as np
+from openvino.runtime import Node
+from openvino.runtime.opset_utils import _get_node_factory
+from openvino.runtime.utils.decorators import nameable_op
+from openvino.runtime.utils.types import (
+    NodeInput,
+    as_nodes,
+    as_node,
+    make_constant_node,
+)
+
+_get_node_factory_opset9 = partial(_get_node_factory, "opset9")
+
+
+# -------------------------------------------- ops ------------------------------------------------
+
+
+@nameable_op
+def eye(
+    num_rows: NodeInput,
+    num_columns: NodeInput,
+    diagonal_index: NodeInput,
+    output_type: str,
+    batch_shape: Optional[NodeInput] = None,
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs eye operation.
+
+    :param num_rows: The node providing row number tensor.
+    :param num_columns: The node providing column number tensor.
+    :param diagonal_index: The node providing the index of the diagonal to be populated.
+    :param output_type: Specifies the output tensor type, supports any numeric types.
+    :param batch_shape: The node providing the leading batch dimensions of output shape. Optionally.
+    :param name: The optional new name for output node.
+    :return: New node performing deformable convolution operation.
+    """
+    if batch_shape is not None:
+        inputs = as_nodes(num_rows, num_columns, diagonal_index, batch_shape, name=name)
+    else:
+        inputs = as_nodes(num_rows, num_columns, diagonal_index, name=name)
+
+    return _get_node_factory_opset9().create("Eye", inputs, {"output_type": output_type})
+
+
+@nameable_op
+def non_max_suppression(
+    boxes: NodeInput,
+    scores: NodeInput,
+    max_output_boxes_per_class: Optional[NodeInput] = None,
+    iou_threshold: Optional[NodeInput] = None,
+    score_threshold: Optional[NodeInput] = None,
+    soft_nms_sigma: Optional[NodeInput] = None,
+    box_encoding: str = "corner",
+    sort_result_descending: bool = True,
+    output_type: str = "i64",
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs NonMaxSuppression.
+
+    :param boxes: Tensor with box coordinates.
+    :param scores: Tensor with box scores.
+    :param max_output_boxes_per_class: Tensor Specifying maximum number of boxes
+                                        to be selected per class.
+    :param iou_threshold: Tensor specifying intersection over union threshold
+    :param score_threshold: Tensor specifying minimum score to consider box for the processing.
+    :param soft_nms_sigma: Tensor specifying the sigma parameter for Soft-NMS.
+    :param box_encoding: Format of boxes data encoding.
+    :param sort_result_descending: Flag that specifies whenever it is necessary to sort selected
+                                   boxes across batches or not.
+    :param output_type: Output element type.
+    :return: The new node which performs NonMaxSuppression
+    """
+    max_output_boxes_per_class = max_output_boxes_per_class if max_output_boxes_per_class is not None else make_constant_node(0, np.int64)
+    iou_threshold = iou_threshold if iou_threshold is not None else make_constant_node(0, np.float32)
+    score_threshold = score_threshold if score_threshold is not None else make_constant_node(0, np.float32)
+    soft_nms_sigma = soft_nms_sigma if soft_nms_sigma is not None else make_constant_node(0, np.float32)
+
+    inputs = as_nodes(boxes, scores, max_output_boxes_per_class, iou_threshold, score_threshold, soft_nms_sigma, name=name)
+
+    attributes = {
+        "box_encoding": box_encoding,
+        "sort_result_descending": sort_result_descending,
+        "output_type": output_type,
+    }
+
+    return _get_node_factory_opset9().create("NonMaxSuppression", inputs, attributes)
+
+
+def roi_align(
+    data: NodeInput,
+    rois: NodeInput,
+    batch_indices: NodeInput,
+    pooled_h: int,
+    pooled_w: int,
+    sampling_ratio: int,
+    spatial_scale: float,
+    mode: str,
+    aligned_mode: Optional[str] = "asymmetric",
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs ROIAlign 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 mode: Method to perform pooling to produce output feature map elements. Avaiable modes are:
+                         - 'max' - maximum pooling
+                         - 'avg' - average pooling
+    :param aligned_mode: Specifies how to transform the coordinate in original tensor to the resized tensor.
+                         Mode 'asymmetric' is the default value. Optional. Avaiable aligned modes are:
+                         - 'asymmetric'
+                         - 'half_pixel_for_nn'
+                         - 'half_pixel'
+    :param name: The optional name for the output node
+
+    :return: The new node which performs ROIAlign
+    """
+    inputs = as_nodes(data, rois, batch_indices, name=name)
+    attributes = {
+        "pooled_h": pooled_h,
+        "pooled_w": pooled_w,
+        "sampling_ratio": sampling_ratio,
+        "spatial_scale": spatial_scale,
+        "mode": mode,
+        "aligned_mode": aligned_mode,
+    }
+    return _get_node_factory_opset9().create("ROIAlign", inputs, attributes)
+
+
+def softsign(node: NodeInput, name: Optional[str] = None) -> Node:
+    """Apply SoftSign operation on the input node element-wise.
+
+    :param node: One of: input node, array or scalar.
+    :param name: The optional name for the output node.
+    :return: New node with SoftSign operation applied on each element of it.
+    """
+    return _get_node_factory_opset9().create("SoftSign", [as_node(node, name=name)], {})
+
+
+@nameable_op
+def rdft(
+    data: NodeInput,
+    axes: NodeInput,
+    signal_size: Optional[NodeInput] = None,
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs RDFT operation.
+
+    :param data: Tensor with data.
+    :param axes: Tensor with axes to transform.
+    :param signal_size: Optional tensor specifying signal size with respect to axes from the input 'axes'.
+    :param name: Optional output node name.
+    :return: The new node which performs RDFT 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_opset9().create("RDFT", inputs)
+
+
+@nameable_op
+def irdft(
+    data: NodeInput,
+    axes: NodeInput,
+    signal_size: Optional[NodeInput] = None,
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs IRDFT operation.
+
+    :param data: Tensor with data.
+    :param axes: Tensor with axes to transform.
+    :param signal_size: Optional tensor specifying signal size with respect to axes from the input 'axes'.
+    :param name: Optional output node name.
+    :return: The new node which performs IRDFT 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_opset9().create("IRDFT", inputs)
+
+
+@nameable_op
+def multiclass_nms(
+    boxes: NodeInput,
+    scores: NodeInput,
+    roisnum: Optional[NodeInput] = None,
+    sort_result_type: Optional[str] = "none",
+    sort_result_across_batch: Optional[bool] = False,
+    output_type: Optional[str] = "i64",
+    iou_threshold: Optional[float] = 0.0,
+    score_threshold: Optional[float] = 0.0,
+    nms_top_k: Optional[int] = -1,
+    keep_top_k: Optional[int] = -1,
+    background_class: Optional[int] = -1,
+    nms_eta: Optional[float] = 1.0,
+    normalized: Optional[bool] = True,
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs MulticlassNms.
+
+    :param boxes: Tensor with box coordinates.
+    :param scores: Tensor with box scores.
+    :param roisnum: Tensor with roisnum. Specifies the number of rois in each image. Required when
+                    'scores' is a 2-dimensional tensor.
+    :param sort_result_type: Specifies order of output elements, possible values:
+                             'class': sort selected boxes by class id (ascending)
+                             'score': sort selected boxes by score (descending)
+                             'none': do not guarantee the order.
+    :param sort_result_across_batch: Specifies whenever it is necessary to sort selected boxes
+                                     across batches or not
+    :param output_type: Specifies the output tensor type, possible values:
+                        'i64', 'i32'
+    :param iou_threshold: Specifies intersection over union threshold
+    :param score_threshold: Specifies minimum score to consider box for the processing
+    :param nms_top_k: Specifies maximum number of boxes to be selected per class, -1 meaning
+                      to keep all boxes
+    :param keep_top_k: Specifies maximum number of boxes to be selected per batch element, -1
+                       meaning to keep all boxes
+    :param background_class: Specifies the background class id, -1 meaning to keep all classes
+    :param nms_eta: Specifies eta parameter for adpative NMS, in close range [0, 1.0]
+    :param normalized: Specifies whether boxes are normalized or not
+    :param name: The optional name for the output node
+    :return: The new node which performs MuticlassNms
+    """
+    if roisnum is None:
+        inputs = as_nodes(boxes, scores, name=name)
+    else:
+        inputs = as_nodes(boxes, scores, roisnum, name=name)
+
+    attributes = {
+        "sort_result_type": sort_result_type,
+        "sort_result_across_batch": sort_result_across_batch,
+        "output_type": output_type,
+        "iou_threshold": iou_threshold,
+        "score_threshold": score_threshold,
+        "nms_top_k": nms_top_k,
+        "keep_top_k": keep_top_k,
+        "background_class": background_class,
+        "nms_eta": nms_eta,
+        "normalized": normalized,
+    }
+
+    return _get_node_factory_opset9().create("MulticlassNms", inputs, attributes)
+
+
+@nameable_op
+def generate_proposals(
+    im_info: NodeInput,
+    anchors: NodeInput,
+    deltas: NodeInput,
+    scores: NodeInput,
+    min_size: float,
+    nms_threshold: float,
+    pre_nms_count: int,
+    post_nms_count: int,
+    normalized: bool = True,
+    nms_eta: float = 1.0,
+    roi_num_type: str = "i64",
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs GenerateProposals operation.
+
+    :param im_info: Input with image info.
+    :param anchors: Input anchors.
+    :param deltas: Input deltas.
+    :param scores: Input scores.
+    :param min_size: Specifies minimum box width and height.
+    :param nms_threshold: Specifies threshold to be used in the NMS stage.
+    :param pre_nms_count: Specifies number of top-n proposals before NMS.
+    :param post_nms_count: Specifies number of top-n proposals after NMS.
+    :param normalized: Specifies whether proposal bboxes are normalized or not. Optional attribute, default value is `True`.
+    :param nms_eta: Specifies eta parameter for adaptive NMS., must be in range `[0.0, 1.0]`. Optional attribute, default value is `1.0`.
+    :param roi_num_type: Specifies the element type of the third output `rpnroisnum`. Optional attribute, range of values: `i64` (default) or `i32`.
+    :param name: The optional name for the output node.
+    :return: New node performing GenerateProposals operation.
+    """
+    inputs = as_nodes(im_info, anchors, deltas, scores, name=name)
+
+    attributes = {
+        "min_size": min_size,
+        "nms_threshold": nms_threshold,
+        "pre_nms_count": pre_nms_count,
+        "post_nms_count": post_nms_count,
+        "normalized": normalized,
+        "nms_eta": nms_eta,
+        "roi_num_type": roi_num_type,
+    }
+
+    return _get_node_factory_opset9().create("GenerateProposals", inputs, attributes)
+
+
+def grid_sample(
+    data: NodeInput,
+    grid: NodeInput,
+    attributes: dict,
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs GridSample operation.
+
+    :param data: The input image.
+    :param grid: Grid values (normalized input coordinates).
+    :param attributes: A dictionary containing GridSample's attributes.
+    :param name: Optional name of the node.
+
+    Available attributes:
+
+    * align_corners A flag which specifies whether to align the grid extrema values
+                    with the borders or center points of the input tensor's border pixels.
+                    Range of values: true, false
+                    Default value: false
+                    Required: no
+    * mode          Specifies the type of interpolation.
+                    Range of values: bilinear, bicubic, nearest
+                    Default value: bilinear
+                    Required: no
+    * padding_mode  Specifies how the out-of-bounds coordinates should be handled.
+                    Range of values: zeros, border, reflection
+                    Default value: zeros
+                    Required: no
+
+    :return: A new GridSample node.
+    """
+    return _get_node_factory_opset9().create("GridSample", as_nodes(data, grid, name=name), attributes)

intel_npu_acceleration_library/external/openvino/runtime/opset_utils.py

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Optional
+import numpy as np
+
+from openvino.runtime import Node
+from openvino.runtime.utils.decorators import nameable_op
+from openvino.runtime.utils.node_factory import NodeFactory
+from openvino.runtime.utils.types import (
+    as_node,
+    NodeInput,
+)
+
+
+def _get_node_factory(opset_version: Optional[str] = None) -> NodeFactory:
+    """Return NodeFactory configured to create operators from specified opset version."""
+    if opset_version:
+        return NodeFactory(opset_version)
+    else:
+        return NodeFactory()

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

@@ -0,0 +1,19 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+# type: ignore
+# flake8: noqa
+
+from openvino._pyopenvino.passes import ModelPass, Matcher, MatcherPass, PassBase, WrapType, Or, AnyInput, Optional
+from openvino._pyopenvino.passes import (
+    consumers_count,
+    has_static_dim,
+    has_static_dims,
+    has_static_shape,
+    has_static_rank,
+    rank_equals,
+    type_matches,
+    type_matches_any,
+)
+from openvino._pyopenvino.passes import Serialize, ConstantFolding, VisualizeTree, MakeStateful, LowLatency2, ConvertFP32ToFP16, Version
+from openvino.runtime.passes.manager import Manager
+from openvino.runtime.passes.graph_rewrite import GraphRewrite, BackwardGraphRewrite

intel_npu_acceleration_library/external/openvino/runtime/passes/graph_rewrite.py

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+# type: ignore
+from openvino._pyopenvino.passes import MatcherPass
+from openvino._pyopenvino.passes import GraphRewrite as GraphRewriteBase
+from openvino._pyopenvino.passes import BackwardGraphRewrite as BackwardGraphRewriteBase
+
+
+class GraphRewrite(GraphRewriteBase):
+    """GraphRewrite that additionally holds python transformations objects."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.passes_list = []  # need to keep python instances alive
+
+    def add_matcher(self, transformation: MatcherPass) -> MatcherPass:
+        """Append MatcherPass instance to the end of execution list."""
+        self.passes_list.append(transformation)
+        return super().add_matcher(transformation)
+
+
+class BackwardGraphRewrite(BackwardGraphRewriteBase):
+    """BackwardGraphRewriteBase that additionally holds python transformations objects."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.passes_list = []  # need to keep python instances alive
+
+    def add_matcher(self, transformation: MatcherPass) -> MatcherPass:
+        """Append MatcherPass instance to the end of execution list."""
+        self.passes_list.append(transformation)
+        return super().add_matcher(transformation)

intel_npu_acceleration_library/external/openvino/runtime/passes/manager.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+# type: ignore
+from openvino._pyopenvino.passes import Manager as ManagerBase
+from openvino._pyopenvino.passes import PassBase
+
+
+class Manager(ManagerBase):
+    """Manager that additionally holds transformations objects."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.passes_list = []  # need to keep python instances alive
+
+    def register_pass(self, *args, **kwargs) -> PassBase:
+        """Register transformation for further execution."""
+        for arg in args:
+            if isinstance(arg, PassBase):
+                self.passes_list.append(arg)
+
+        for arg in kwargs.values():
+            if isinstance(arg, PassBase):
+                self.passes_list.append(arg)
+
+        return super().register_pass(*args, **kwargs)

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

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# Enums
+from openvino._pyopenvino.properties import Affinity
+from openvino._pyopenvino.properties import CacheMode
+
+# Properties
+from openvino._pyopenvino.properties import enable_profiling
+from openvino._pyopenvino.properties import cache_dir
+from openvino._pyopenvino.properties import cache_mode
+from openvino._pyopenvino.properties import auto_batch_timeout
+from openvino._pyopenvino.properties import num_streams
+from openvino._pyopenvino.properties import inference_num_threads
+from openvino._pyopenvino.properties import compilation_num_threads
+from openvino._pyopenvino.properties import affinity
+from openvino._pyopenvino.properties import force_tbb_terminate
+from openvino._pyopenvino.properties import enable_mmap
+from openvino._pyopenvino.properties import supported_properties
+from openvino._pyopenvino.properties import available_devices
+from openvino._pyopenvino.properties import model_name
+from openvino._pyopenvino.properties import optimal_number_of_infer_requests
+from openvino._pyopenvino.properties import range_for_streams
+from openvino._pyopenvino.properties import optimal_batch_size
+from openvino._pyopenvino.properties import max_batch_size
+from openvino._pyopenvino.properties import range_for_async_infer_requests
+from openvino._pyopenvino.properties import execution_devices
+from openvino._pyopenvino.properties import loaded_from_cache
+
+# Submodules
+from openvino.runtime.properties import hint
+from openvino._pyopenvino.properties import intel_cpu
+from openvino._pyopenvino.properties import intel_gpu
+from openvino._pyopenvino.properties import intel_auto
+from openvino._pyopenvino.properties import device
+from openvino._pyopenvino.properties import log
+from openvino._pyopenvino.properties import streams

intel_npu_acceleration_library/external/openvino/runtime/properties/hint/__init__.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# Enums
+from openvino._pyopenvino.properties.hint import Priority
+from openvino._pyopenvino.properties.hint import SchedulingCoreType
+from openvino._pyopenvino.properties.hint import ModelDistributionPolicy
+from openvino._pyopenvino.properties.hint import ExecutionMode
+from openvino._pyopenvino.properties.hint import PerformanceMode
+
+# Properties
+from openvino._pyopenvino.properties.hint import inference_precision
+from openvino._pyopenvino.properties.hint import model_priority
+from openvino._pyopenvino.properties.hint import performance_mode
+from openvino._pyopenvino.properties.hint import enable_cpu_pinning
+from openvino._pyopenvino.properties.hint import scheduling_core_type
+from openvino._pyopenvino.properties.hint import model_distribution_policy
+from openvino._pyopenvino.properties.hint import enable_hyper_threading
+from openvino._pyopenvino.properties.hint import execution_mode
+from openvino._pyopenvino.properties.hint import num_requests
+from openvino._pyopenvino.properties.hint import model
+from openvino._pyopenvino.properties.hint import allow_auto_batching
+from openvino._pyopenvino.properties.hint import dynamic_quantization_group_size
+from openvino._pyopenvino.properties.hint import kv_cache_precision