From 951c5fdae9fcd081954517ed76280962f52614d3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tomasz=20Do=C5=82bniak?= Date: Wed, 22 Mar 2023 19:12:16 +0100 Subject: [PATCH] Interpolate 11 exposed to Python (#16465) --- docs/api/ie_python_api/api.rst | 8 +- src/bindings/python/setup.py | 1 + .../src/compatibility/ngraph/__init__.py | 348 +++++++++--------- .../compatibility/ngraph/opset11/__init__.py | 177 +++++++++ .../src/compatibility/ngraph/opset11/ops.py | 77 ++++ .../ngraph/utils/node_factory.py | 2 +- .../compatibility/pyngraph/node_factory.cpp | 2 +- .../python/src/openvino/runtime/__init__.py | 33 +- .../src/openvino/runtime/opset11/__init__.py | 178 +++++++++ .../src/openvino/runtime/opset11/ops.py | 77 ++++ .../openvino/runtime/utils/node_factory.py | 2 +- .../src/pyopenvino/graph/node_factory.cpp | 2 +- .../python/tests/test_graph/test_create_op.py | 28 +- .../test_ngraph/test_create_op.py | 25 +- 14 files changed, 760 insertions(+), 200 deletions(-) create mode 100644 src/bindings/python/src/compatibility/ngraph/opset11/__init__.py create mode 100644 src/bindings/python/src/compatibility/ngraph/opset11/ops.py create mode 100644 src/bindings/python/src/openvino/runtime/opset11/__init__.py create mode 100644 src/bindings/python/src/openvino/runtime/opset11/ops.py diff --git a/docs/api/ie_python_api/api.rst b/docs/api/ie_python_api/api.rst index c06cc2b2fb8..5faa85f4e05 100644 --- a/docs/api/ie_python_api/api.rst +++ b/docs/api/ie_python_api/api.rst @@ -73,6 +73,12 @@ OpenVINO Python API openvino.runtime.opset10 +.. autosummary:: + :toctree: _autosummary + :template: custom-module-template.rst + + openvino.runtime.opset11 + .. autosummary:: :toctree: _autosummary :template: custom-module-template.rst @@ -95,4 +101,4 @@ OpenVINO Python API :maxdepth: 2 :hidden: - compatibility \ No newline at end of file + compatibility diff --git a/src/bindings/python/setup.py b/src/bindings/python/setup.py index 021e37875e3..6205f70aeb4 100644 --- a/src/bindings/python/setup.py +++ b/src/bindings/python/setup.py @@ -55,6 +55,7 @@ packages = [ "openvino.runtime.opset8", "openvino.runtime.opset9", "openvino.runtime.opset10", + "openvino.runtime.opset11", "openvino.runtime.utils", "openvino.runtime.op", "openvino.runtime.op.util", diff --git a/src/bindings/python/src/compatibility/ngraph/__init__.py b/src/bindings/python/src/compatibility/ngraph/__init__.py index 3109d9e3d1d..d80f2199dfc 100644 --- a/src/bindings/python/src/compatibility/ngraph/__init__.py +++ b/src/bindings/python/src/compatibility/ngraph/__init__.py @@ -18,180 +18,180 @@ from ngraph.impl import Node from ngraph.impl import PartialShape from ngraph.helpers import function_from_cnn from ngraph.helpers import function_to_cnn -from ngraph.opset10 import absolute -from ngraph.opset10 import absolute as abs -from ngraph.opset10 import acos -from ngraph.opset10 import acosh -from ngraph.opset10 import adaptive_avg_pool -from ngraph.opset10 import adaptive_max_pool -from ngraph.opset10 import add -from ngraph.opset10 import asin -from ngraph.opset10 import asinh -from ngraph.opset10 import assign -from ngraph.opset10 import atan -from ngraph.opset10 import atanh -from ngraph.opset10 import avg_pool -from ngraph.opset10 import batch_norm_inference -from ngraph.opset10 import batch_to_space -from ngraph.opset10 import binary_convolution -from ngraph.opset10 import broadcast -from ngraph.opset10 import bucketize -from ngraph.opset10 import ceiling -from ngraph.opset10 import ceiling as ceil -from ngraph.opset10 import clamp -from ngraph.opset10 import concat -from ngraph.opset10 import constant -from ngraph.opset10 import convert -from ngraph.opset10 import convert_like -from ngraph.opset10 import convolution -from ngraph.opset10 import convolution_backprop_data -from ngraph.opset10 import cos -from ngraph.opset10 import cosh -from ngraph.opset10 import ctc_greedy_decoder -from ngraph.opset10 import ctc_greedy_decoder_seq_len -from ngraph.opset10 import ctc_loss -from ngraph.opset10 import cum_sum -from ngraph.opset10 import cum_sum as cumsum -from ngraph.opset10 import deformable_convolution -from ngraph.opset10 import deformable_psroi_pooling -from ngraph.opset10 import depth_to_space -from ngraph.opset10 import detection_output -from ngraph.opset10 import dft -from ngraph.opset10 import divide -from ngraph.opset10 import einsum -from ngraph.opset10 import elu -from ngraph.opset10 import embedding_bag_offsets_sum -from ngraph.opset10 import embedding_bag_packed_sum -from ngraph.opset10 import embedding_segments_sum -from ngraph.opset10 import extract_image_patches -from ngraph.opset10 import equal -from ngraph.opset10 import erf -from ngraph.opset10 import exp -from ngraph.opset10 import eye -from ngraph.opset10 import fake_quantize -from ngraph.opset10 import floor -from ngraph.opset10 import floor_mod -from ngraph.opset10 import gather -from ngraph.opset10 import gather_elements -from ngraph.opset10 import gather_nd -from ngraph.opset10 import gather_tree -from ngraph.opset10 import gelu -from ngraph.opset10 import generate_proposals -from ngraph.opset10 import greater -from ngraph.opset10 import greater_equal -from ngraph.opset10 import grid_sample -from ngraph.opset10 import grn -from ngraph.opset10 import group_convolution -from ngraph.opset10 import group_convolution_backprop_data -from ngraph.opset10 import gru_cell -from ngraph.opset10 import gru_sequence -from ngraph.opset10 import hard_sigmoid -from ngraph.opset10 import hsigmoid -from ngraph.opset10 import hswish -from ngraph.opset10 import idft -from ngraph.opset10 import if_op -from ngraph.opset10 import interpolate -from ngraph.opset10 import irdft -from ngraph.opset10 import is_finite -from ngraph.opset10 import is_inf -from ngraph.opset10 import is_nan -from ngraph.opset10 import i420_to_bgr -from ngraph.opset10 import i420_to_rgb -from ngraph.opset10 import less -from ngraph.opset10 import less_equal -from ngraph.opset10 import log -from ngraph.opset10 import logical_and -from ngraph.opset10 import logical_not -from ngraph.opset10 import logical_or -from ngraph.opset10 import logical_xor -from ngraph.opset10 import log_softmax -from ngraph.opset10 import loop -from ngraph.opset10 import lrn -from ngraph.opset10 import lstm_cell -from ngraph.opset10 import lstm_sequence -from ngraph.opset10 import matmul -from ngraph.opset10 import matrix_nms -from ngraph.opset10 import max_pool -from ngraph.opset10 import maximum -from ngraph.opset10 import minimum -from ngraph.opset10 import mish -from ngraph.opset10 import mod -from ngraph.opset10 import multiclass_nms -from ngraph.opset10 import multiply -from ngraph.opset10 import mvn -from ngraph.opset10 import negative -from ngraph.opset10 import non_max_suppression -from ngraph.opset10 import non_zero -from ngraph.opset10 import normalize_l2 -from ngraph.opset10 import not_equal -from ngraph.opset10 import nv12_to_bgr -from ngraph.opset10 import nv12_to_rgb -from ngraph.opset10 import one_hot -from ngraph.opset10 import pad -from ngraph.opset10 import parameter -from ngraph.opset10 import power -from ngraph.opset10 import prelu -from ngraph.opset10 import prior_box -from ngraph.opset10 import prior_box_clustered -from ngraph.opset10 import psroi_pooling -from ngraph.opset10 import proposal -from ngraph.opset10 import random_uniform -from ngraph.opset10 import range -from ngraph.opset10 import rdft -from ngraph.opset10 import read_value -from ngraph.opset10 import reduce_l1 -from ngraph.opset10 import reduce_l2 -from ngraph.opset10 import reduce_logical_and -from ngraph.opset10 import reduce_logical_or -from ngraph.opset10 import reduce_max -from ngraph.opset10 import reduce_mean -from ngraph.opset10 import reduce_min -from ngraph.opset10 import reduce_prod -from ngraph.opset10 import reduce_sum -from ngraph.opset10 import region_yolo -from ngraph.opset10 import reorg_yolo -from ngraph.opset10 import relu -from ngraph.opset10 import reshape -from ngraph.opset10 import result -from ngraph.opset10 import reverse_sequence -from ngraph.opset10 import rnn_cell -from ngraph.opset10 import rnn_sequence -from ngraph.opset10 import roi_align -from ngraph.opset10 import roi_pooling -from ngraph.opset10 import roll -from ngraph.opset10 import round -from ngraph.opset10 import scatter_elements_update -from ngraph.opset10 import scatter_update -from ngraph.opset10 import select -from ngraph.opset10 import selu -from ngraph.opset10 import shape_of -from ngraph.opset10 import shuffle_channels -from ngraph.opset10 import sigmoid -from ngraph.opset10 import sign -from ngraph.opset10 import sin -from ngraph.opset10 import sinh -from ngraph.opset10 import slice -from ngraph.opset10 import softmax -from ngraph.opset10 import softplus -from ngraph.opset10 import softsign -from ngraph.opset10 import space_to_batch -from ngraph.opset10 import space_to_depth -from ngraph.opset10 import split -from ngraph.opset10 import sqrt -from ngraph.opset10 import squared_difference -from ngraph.opset10 import squeeze -from ngraph.opset10 import strided_slice -from ngraph.opset10 import subtract -from ngraph.opset10 import swish -from ngraph.opset10 import tan -from ngraph.opset10 import tanh -from ngraph.opset10 import tensor_iterator -from ngraph.opset10 import tile -from ngraph.opset10 import topk -from ngraph.opset10 import transpose -from ngraph.opset10 import unique -from ngraph.opset10 import unsqueeze -from ngraph.opset10 import variadic_split +from ngraph.opset11 import absolute +from ngraph.opset11 import absolute as abs +from ngraph.opset11 import acos +from ngraph.opset11 import acosh +from ngraph.opset11 import adaptive_avg_pool +from ngraph.opset11 import adaptive_max_pool +from ngraph.opset11 import add +from ngraph.opset11 import asin +from ngraph.opset11 import asinh +from ngraph.opset11 import assign +from ngraph.opset11 import atan +from ngraph.opset11 import atanh +from ngraph.opset11 import avg_pool +from ngraph.opset11 import batch_norm_inference +from ngraph.opset11 import batch_to_space +from ngraph.opset11 import binary_convolution +from ngraph.opset11 import broadcast +from ngraph.opset11 import bucketize +from ngraph.opset11 import ceiling +from ngraph.opset11 import ceiling as ceil +from ngraph.opset11 import clamp +from ngraph.opset11 import concat +from ngraph.opset11 import constant +from ngraph.opset11 import convert +from ngraph.opset11 import convert_like +from ngraph.opset11 import convolution +from ngraph.opset11 import convolution_backprop_data +from ngraph.opset11 import cos +from ngraph.opset11 import cosh +from ngraph.opset11 import ctc_greedy_decoder +from ngraph.opset11 import ctc_greedy_decoder_seq_len +from ngraph.opset11 import ctc_loss +from ngraph.opset11 import cum_sum +from ngraph.opset11 import cum_sum as cumsum +from ngraph.opset11 import deformable_convolution +from ngraph.opset11 import deformable_psroi_pooling +from ngraph.opset11 import depth_to_space +from ngraph.opset11 import detection_output +from ngraph.opset11 import dft +from ngraph.opset11 import divide +from ngraph.opset11 import einsum +from ngraph.opset11 import elu +from ngraph.opset11 import embedding_bag_offsets_sum +from ngraph.opset11 import embedding_bag_packed_sum +from ngraph.opset11 import embedding_segments_sum +from ngraph.opset11 import extract_image_patches +from ngraph.opset11 import equal +from ngraph.opset11 import erf +from ngraph.opset11 import exp +from ngraph.opset11 import eye +from ngraph.opset11 import fake_quantize +from ngraph.opset11 import floor +from ngraph.opset11 import floor_mod +from ngraph.opset11 import gather +from ngraph.opset11 import gather_elements +from ngraph.opset11 import gather_nd +from ngraph.opset11 import gather_tree +from ngraph.opset11 import gelu +from ngraph.opset11 import generate_proposals +from ngraph.opset11 import greater +from ngraph.opset11 import greater_equal +from ngraph.opset11 import grid_sample +from ngraph.opset11 import grn +from ngraph.opset11 import group_convolution +from ngraph.opset11 import group_convolution_backprop_data +from ngraph.opset11 import gru_cell +from ngraph.opset11 import gru_sequence +from ngraph.opset11 import hard_sigmoid +from ngraph.opset11 import hsigmoid +from ngraph.opset11 import hswish +from ngraph.opset11 import idft +from ngraph.opset11 import if_op +from ngraph.opset11 import interpolate +from ngraph.opset11 import irdft +from ngraph.opset11 import is_finite +from ngraph.opset11 import is_inf +from ngraph.opset11 import is_nan +from ngraph.opset11 import i420_to_bgr +from ngraph.opset11 import i420_to_rgb +from ngraph.opset11 import less +from ngraph.opset11 import less_equal +from ngraph.opset11 import log +from ngraph.opset11 import logical_and +from ngraph.opset11 import logical_not +from ngraph.opset11 import logical_or +from ngraph.opset11 import logical_xor +from ngraph.opset11 import log_softmax +from ngraph.opset11 import loop +from ngraph.opset11 import lrn +from ngraph.opset11 import lstm_cell +from ngraph.opset11 import lstm_sequence +from ngraph.opset11 import matmul +from ngraph.opset11 import matrix_nms +from ngraph.opset11 import max_pool +from ngraph.opset11 import maximum +from ngraph.opset11 import minimum +from ngraph.opset11 import mish +from ngraph.opset11 import mod +from ngraph.opset11 import multiclass_nms +from ngraph.opset11 import multiply +from ngraph.opset11 import mvn +from ngraph.opset11 import negative +from ngraph.opset11 import non_max_suppression +from ngraph.opset11 import non_zero +from ngraph.opset11 import normalize_l2 +from ngraph.opset11 import not_equal +from ngraph.opset11 import nv12_to_bgr +from ngraph.opset11 import nv12_to_rgb +from ngraph.opset11 import one_hot +from ngraph.opset11 import pad +from ngraph.opset11 import parameter +from ngraph.opset11 import power +from ngraph.opset11 import prelu +from ngraph.opset11 import prior_box +from ngraph.opset11 import prior_box_clustered +from ngraph.opset11 import psroi_pooling +from ngraph.opset11 import proposal +from ngraph.opset11 import random_uniform +from ngraph.opset11 import range +from ngraph.opset11 import rdft +from ngraph.opset11 import read_value +from ngraph.opset11 import reduce_l1 +from ngraph.opset11 import reduce_l2 +from ngraph.opset11 import reduce_logical_and +from ngraph.opset11 import reduce_logical_or +from ngraph.opset11 import reduce_max +from ngraph.opset11 import reduce_mean +from ngraph.opset11 import reduce_min +from ngraph.opset11 import reduce_prod +from ngraph.opset11 import reduce_sum +from ngraph.opset11 import region_yolo +from ngraph.opset11 import reorg_yolo +from ngraph.opset11 import relu +from ngraph.opset11 import reshape +from ngraph.opset11 import result +from ngraph.opset11 import reverse_sequence +from ngraph.opset11 import rnn_cell +from ngraph.opset11 import rnn_sequence +from ngraph.opset11 import roi_align +from ngraph.opset11 import roi_pooling +from ngraph.opset11 import roll +from ngraph.opset11 import round +from ngraph.opset11 import scatter_elements_update +from ngraph.opset11 import scatter_update +from ngraph.opset11 import select +from ngraph.opset11 import selu +from ngraph.opset11 import shape_of +from ngraph.opset11 import shuffle_channels +from ngraph.opset11 import sigmoid +from ngraph.opset11 import sign +from ngraph.opset11 import sin +from ngraph.opset11 import sinh +from ngraph.opset11 import slice +from ngraph.opset11 import softmax +from ngraph.opset11 import softplus +from ngraph.opset11 import softsign +from ngraph.opset11 import space_to_batch +from ngraph.opset11 import space_to_depth +from ngraph.opset11 import split +from ngraph.opset11 import sqrt +from ngraph.opset11 import squared_difference +from ngraph.opset11 import squeeze +from ngraph.opset11 import strided_slice +from ngraph.opset11 import subtract +from ngraph.opset11 import swish +from ngraph.opset11 import tan +from ngraph.opset11 import tanh +from ngraph.opset11 import tensor_iterator +from ngraph.opset11 import tile +from ngraph.opset11 import topk +from ngraph.opset11 import transpose +from ngraph.opset11 import unique +from ngraph.opset11 import unsqueeze +from ngraph.opset11 import variadic_split # Extend Node class to support binary operators diff --git a/src/bindings/python/src/compatibility/ngraph/opset11/__init__.py b/src/bindings/python/src/compatibility/ngraph/opset11/__init__.py new file mode 100644 index 00000000000..91f84b81f41 --- /dev/null +++ b/src/bindings/python/src/compatibility/ngraph/opset11/__init__.py @@ -0,0 +1,177 @@ +# Copyright (C) 2018-2023 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +from ngraph.opset1.ops import absolute +from ngraph.opset1.ops import absolute as abs +from ngraph.opset1.ops import acos +from ngraph.opset4.ops import acosh +from ngraph.opset8.ops import adaptive_avg_pool +from ngraph.opset8.ops import adaptive_max_pool +from ngraph.opset1.ops import add +from ngraph.opset1.ops import asin +from ngraph.opset4.ops import asinh +from ngraph.opset3.ops import assign +from ngraph.opset1.ops import atan +from ngraph.opset4.ops import atanh +from ngraph.opset1.ops import avg_pool +from ngraph.opset5.ops import batch_norm_inference +from ngraph.opset2.ops import batch_to_space +from ngraph.opset1.ops import binary_convolution +from ngraph.opset3.ops import broadcast +from ngraph.opset3.ops import bucketize +from ngraph.opset1.ops import ceiling +from ngraph.opset1.ops import ceiling as ceil +from ngraph.opset1.ops import clamp +from ngraph.opset1.ops import concat +from ngraph.opset1.ops import constant +from ngraph.opset1.ops import convert +from ngraph.opset1.ops import convert_like +from ngraph.opset1.ops import convolution +from ngraph.opset1.ops import convolution_backprop_data +from ngraph.opset1.ops import cos +from ngraph.opset1.ops import cosh +from ngraph.opset1.ops import ctc_greedy_decoder +from ngraph.opset6.ops import ctc_greedy_decoder_seq_len +from ngraph.opset4.ops import ctc_loss +from ngraph.opset3.ops import cum_sum +from ngraph.opset3.ops import cum_sum as cumsum +from ngraph.opset8.ops import deformable_convolution +from ngraph.opset1.ops import deformable_psroi_pooling +from ngraph.opset1.ops import depth_to_space +from ngraph.opset8.ops import detection_output +from ngraph.opset7.ops import dft +from ngraph.opset1.ops import divide +from ngraph.opset7.ops import einsum +from ngraph.opset1.ops import elu +from ngraph.opset3.ops import embedding_bag_offsets_sum +from ngraph.opset3.ops import embedding_bag_packed_sum +from ngraph.opset3.ops import embedding_segments_sum +from ngraph.opset3.ops import extract_image_patches +from ngraph.opset1.ops import equal +from ngraph.opset1.ops import erf +from ngraph.opset1.ops import exp +from ngraph.opset9.ops import eye +from ngraph.opset1.ops import fake_quantize +from ngraph.opset1.ops import floor +from ngraph.opset1.ops import floor_mod +from ngraph.opset8.ops import gather +from ngraph.opset6.ops import gather_elements +from ngraph.opset8.ops import gather_nd +from ngraph.opset1.ops import gather_tree +from ngraph.opset7.ops import gelu +from ngraph.opset9.ops import generate_proposals +from ngraph.opset1.ops import greater +from ngraph.opset1.ops import greater_equal +from ngraph.opset9.ops import grid_sample +from ngraph.opset1.ops import grn +from ngraph.opset1.ops import group_convolution +from ngraph.opset1.ops import group_convolution_backprop_data +from ngraph.opset3.ops import gru_cell +from ngraph.opset5.ops import gru_sequence +from ngraph.opset1.ops import hard_sigmoid +from ngraph.opset5.ops import hsigmoid +from ngraph.opset4.ops import hswish +from ngraph.opset7.ops import idft +from ngraph.opset8.ops import if_op +from ngraph.opset11.ops import interpolate +from ngraph.opset9.ops import irdft +from ngraph.opset10.ops import is_finite +from ngraph.opset10.ops import is_inf +from ngraph.opset10.ops import is_nan +from ngraph.opset8.ops import i420_to_bgr +from ngraph.opset8.ops import i420_to_rgb +from ngraph.opset1.ops import less +from ngraph.opset1.ops import less_equal +from ngraph.opset1.ops import log +from ngraph.opset1.ops import logical_and +from ngraph.opset1.ops import logical_not +from ngraph.opset1.ops import logical_or +from ngraph.opset1.ops import logical_xor +from ngraph.opset5.ops import log_softmax +from ngraph.opset5.ops import loop +from ngraph.opset1.ops import lrn +from ngraph.opset4.ops import lstm_cell +from ngraph.opset5.ops import lstm_sequence +from ngraph.opset1.ops import matmul +from ngraph.opset8.ops import matrix_nms +from ngraph.opset8.ops import max_pool +from ngraph.opset1.ops import maximum +from ngraph.opset1.ops import minimum +from ngraph.opset4.ops import mish +from ngraph.opset1.ops import mod +from ngraph.opset9.ops import multiclass_nms +from ngraph.opset1.ops import multiply +from ngraph.opset6.ops import mvn +from ngraph.opset1.ops import negative +from ngraph.opset9.ops import non_max_suppression +from ngraph.opset3.ops import non_zero +from ngraph.opset1.ops import normalize_l2 +from ngraph.opset1.ops import not_equal +from ngraph.opset8.ops import nv12_to_bgr +from ngraph.opset8.ops import nv12_to_rgb +from ngraph.opset1.ops import one_hot +from ngraph.opset1.ops import pad +from ngraph.opset1.ops import parameter +from ngraph.opset1.ops import power +from ngraph.opset1.ops import prelu +from ngraph.opset8.ops import prior_box +from ngraph.opset1.ops import prior_box_clustered +from ngraph.opset1.ops import psroi_pooling +from ngraph.opset4.ops import proposal +from ngraph.opset8.ops import random_uniform +from ngraph.opset1.ops import range +from ngraph.opset9.ops import rdft +from ngraph.opset3.ops import read_value +from ngraph.opset4.ops import reduce_l1 +from ngraph.opset4.ops import reduce_l2 +from ngraph.opset1.ops import reduce_logical_and +from ngraph.opset1.ops import reduce_logical_or +from ngraph.opset1.ops import reduce_max +from ngraph.opset1.ops import reduce_mean +from ngraph.opset1.ops import reduce_min +from ngraph.opset1.ops import reduce_prod +from ngraph.opset1.ops import reduce_sum +from ngraph.opset1.ops import region_yolo +from ngraph.opset2.ops import reorg_yolo +from ngraph.opset1.ops import relu +from ngraph.opset1.ops import reshape +from ngraph.opset1.ops import result +from ngraph.opset1.ops import reverse_sequence +from ngraph.opset3.ops import rnn_cell +from ngraph.opset5.ops import rnn_sequence +from ngraph.opset9.ops import roi_align +from ngraph.opset2.ops import roi_pooling +from ngraph.opset7.ops import roll +from ngraph.opset5.ops import round +from ngraph.opset3.ops import scatter_elements_update +from ngraph.opset3.ops import scatter_update +from ngraph.opset1.ops import select +from ngraph.opset1.ops import selu +from ngraph.opset3.ops import shape_of +from ngraph.opset3.ops import shuffle_channels +from ngraph.opset1.ops import sigmoid +from ngraph.opset1.ops import sign +from ngraph.opset1.ops import sin +from ngraph.opset1.ops import sinh +from ngraph.opset8.ops import slice +from ngraph.opset8.ops import softmax +from ngraph.opset4.ops import softplus +from ngraph.opset9.ops import softsign +from ngraph.opset2.ops import space_to_batch +from ngraph.opset1.ops import space_to_depth +from ngraph.opset1.ops import split +from ngraph.opset1.ops import sqrt +from ngraph.opset1.ops import squared_difference +from ngraph.opset1.ops import squeeze +from ngraph.opset1.ops import strided_slice +from ngraph.opset1.ops import subtract +from ngraph.opset4.ops import swish +from ngraph.opset1.ops import tan +from ngraph.opset1.ops import tanh +from ngraph.opset1.ops import tensor_iterator +from ngraph.opset1.ops import tile +from ngraph.opset3.ops import topk +from ngraph.opset1.ops import transpose +from ngraph.opset10.ops import unique +from ngraph.opset1.ops import unsqueeze +from ngraph.opset1.ops import variadic_split diff --git a/src/bindings/python/src/compatibility/ngraph/opset11/ops.py b/src/bindings/python/src/compatibility/ngraph/opset11/ops.py new file mode 100644 index 00000000000..434b778b246 --- /dev/null +++ b/src/bindings/python/src/compatibility/ngraph/opset11/ops.py @@ -0,0 +1,77 @@ +# -*- coding: utf-8 -*- +# Copyright (C) 2018-2023 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +"""Factory functions for all openvino ops.""" +from functools import partial +from typing import List, Optional + +from ngraph.impl import Node +from ngraph.opset_utils import _get_node_factory +from ngraph.utils.decorators import nameable_op +from ngraph.utils.types import ( + NodeInput, + as_nodes, +) + +_get_node_factory_opset11 = partial(_get_node_factory, "opset11") + +# -------------------------------------------- ops ------------------------------------------------ + + +@nameable_op +def interpolate( + image: NodeInput, + scales_or_sizes: NodeInput, + mode: str, + shape_calculation_mode: str, + pads_begin: Optional[List[int]] = None, + pads_end: Optional[List[int]] = None, + coordinate_transformation_mode: str = "half_pixel", + nearest_mode: str = "round_prefer_floor", + antialias: bool = False, + cube_coeff: float = -0.75, + axes: Optional[NodeInput] = None, + name: Optional[str] = None, +) -> Node: + """Perfors the interpolation of the input tensor. + + :param image: The node providing input tensor with data for interpolation. + :param scales_or_sizes: + 1D tensor providing information used to calculate the output shape + of the operation. It might contain floats (scales) or integers(sizes). + :param mode: Specifies type of interpolation. Possible values are: nearest, linear, + linear_onnx, cubic, bilinear_pillow, bicubic_pillow. + :param shape_calculation_mode: + Specifies how the scales_or_sizes input should be interpreted. + :param pads_begin: Specifies the number of pixels to add to the beginning of the image + being interpolated. Default is None. + :param pads_end: Specifies the number of pixels to add to the end of the image being + interpolated. Default is None. + :param coordinate_transformation_mode: + Specifies how to transform the coordinate in the resized tensor to the + coordinate in the original tensor. Default is "half_pixel". + :param nearest_mode: Specifies round mode when mode == nearest and is used only when + mode == nearest. Default is "round_prefer_floor". + :param antialias: Specifies whether to perform anti-aliasing. Default is False. + :param cube_coeff: Specifies the parameter a for cubic interpolation. Default is -0.75. + :param axes: 1D tensor specifying dimension indices where interpolation is applied. + The default is None. + :param name: Optional name for the output node. The default is None. + :return: Node representing the interpolation operation. + """ + attrs = { + "mode": mode, + "shape_calculation_mode": shape_calculation_mode, + "coordinate_transformation_mode": coordinate_transformation_mode, + "nearest_mode": nearest_mode, + "antialias": antialias, + "cube_coeff": cube_coeff, + } + + attrs["pads_begin"] = [] if pads_begin is None else pads_begin + attrs["pads_end"] = [] if pads_end is None else pads_end + + inputs = as_nodes(image, scales_or_sizes) if axes is None else as_nodes(image, scales_or_sizes, axes) + + return _get_node_factory_opset11().create("Interpolate", inputs, attrs) diff --git a/src/bindings/python/src/compatibility/ngraph/utils/node_factory.py b/src/bindings/python/src/compatibility/ngraph/utils/node_factory.py index 6aa951a65b6..0e3d2cc09ce 100644 --- a/src/bindings/python/src/compatibility/ngraph/utils/node_factory.py +++ b/src/bindings/python/src/compatibility/ngraph/utils/node_factory.py @@ -12,7 +12,7 @@ from ngraph.impl import Node, Output from ngraph.exceptions import UserInputError -DEFAULT_OPSET = "opset10" +DEFAULT_OPSET = "opset11" class NodeFactory(object): diff --git a/src/bindings/python/src/compatibility/pyngraph/node_factory.cpp b/src/bindings/python/src/compatibility/pyngraph/node_factory.cpp index 281525cca95..2108a7a057b 100644 --- a/src/bindings/python/src/compatibility/pyngraph/node_factory.cpp +++ b/src/bindings/python/src/compatibility/pyngraph/node_factory.cpp @@ -82,7 +82,7 @@ private: return it->second(); } - const ngraph::OpSet& m_opset = ngraph::get_opset10(); + const ngraph::OpSet& m_opset = ngraph::get_opset11(); std::unordered_map> m_variables; }; } // namespace diff --git a/src/bindings/python/src/openvino/runtime/__init__.py b/src/bindings/python/src/openvino/runtime/__init__.py index 3c2937c214e..9241819e871 100644 --- a/src/bindings/python/src/openvino/runtime/__init__.py +++ b/src/bindings/python/src/openvino/runtime/__init__.py @@ -56,6 +56,7 @@ from openvino.runtime import opset7 from openvino.runtime import opset8 from openvino.runtime import opset9 from openvino.runtime import opset10 +from openvino.runtime import opset11 # Import properties API from openvino._pyopenvino import properties @@ -66,19 +67,19 @@ from openvino.runtime.ie_api import compile_model # Extend Node class to support binary operators -Node.__add__ = opset10.add -Node.__sub__ = opset10.subtract -Node.__mul__ = opset10.multiply -Node.__div__ = opset10.divide -Node.__truediv__ = opset10.divide -Node.__radd__ = lambda left, right: opset10.add(right, left) -Node.__rsub__ = lambda left, right: opset10.subtract(right, left) -Node.__rmul__ = lambda left, right: opset10.multiply(right, left) -Node.__rdiv__ = lambda left, right: opset10.divide(right, left) -Node.__rtruediv__ = lambda left, right: opset10.divide(right, left) -Node.__eq__ = opset10.equal -Node.__ne__ = opset10.not_equal -Node.__lt__ = opset10.less -Node.__le__ = opset10.less_equal -Node.__gt__ = opset10.greater -Node.__ge__ = opset10.greater_equal +Node.__add__ = opset11.add +Node.__sub__ = opset11.subtract +Node.__mul__ = opset11.multiply +Node.__div__ = opset11.divide +Node.__truediv__ = opset11.divide +Node.__radd__ = lambda left, right: opset11.add(right, left) +Node.__rsub__ = lambda left, right: opset11.subtract(right, left) +Node.__rmul__ = lambda left, right: opset11.multiply(right, left) +Node.__rdiv__ = lambda left, right: opset11.divide(right, left) +Node.__rtruediv__ = lambda left, right: opset11.divide(right, left) +Node.__eq__ = opset11.equal +Node.__ne__ = opset11.not_equal +Node.__lt__ = opset11.less +Node.__le__ = opset11.less_equal +Node.__gt__ = opset11.greater +Node.__ge__ = opset11.greater_equal diff --git a/src/bindings/python/src/openvino/runtime/opset11/__init__.py b/src/bindings/python/src/openvino/runtime/opset11/__init__.py new file mode 100644 index 00000000000..79c7068bf83 --- /dev/null +++ b/src/bindings/python/src/openvino/runtime/opset11/__init__.py @@ -0,0 +1,178 @@ +# -*- coding: utf-8 -*- +# Copyright (C) 2018-2023 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.opset3.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.opset11.ops import interpolate +from openvino.runtime.opset9.ops import irdft +from openvino.runtime.opset10.ops import is_finite +from openvino.runtime.opset10.ops import is_inf +from openvino.runtime.opset10.ops import is_nan +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.opset3.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.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.opset10.ops import unique +from openvino.runtime.opset1.ops import unsqueeze +from openvino.runtime.opset1.ops import variadic_split diff --git a/src/bindings/python/src/openvino/runtime/opset11/ops.py b/src/bindings/python/src/openvino/runtime/opset11/ops.py new file mode 100644 index 00000000000..2a54db0069e --- /dev/null +++ b/src/bindings/python/src/openvino/runtime/opset11/ops.py @@ -0,0 +1,77 @@ +# -*- coding: utf-8 -*- +# Copyright (C) 2018-2023 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +"""Factory functions for all openvino ops.""" +from functools import partial +from typing import List, Optional + +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, +) + +_get_node_factory_opset11 = partial(_get_node_factory, "opset11") + +# -------------------------------------------- ops ------------------------------------------------ + + +@nameable_op +def interpolate( + image: NodeInput, + scales_or_sizes: NodeInput, + mode: str, + shape_calculation_mode: str, + pads_begin: Optional[List[int]] = None, + pads_end: Optional[List[int]] = None, + coordinate_transformation_mode: str = "half_pixel", + nearest_mode: str = "round_prefer_floor", + antialias: bool = False, + cube_coeff: float = -0.75, + axes: Optional[NodeInput] = None, + name: Optional[str] = None, +) -> Node: + """Perfors the interpolation of the input tensor. + + :param image: The node providing input tensor with data for interpolation. + :param scales_or_sizes: + 1D tensor providing information used to calculate the output shape + of the operation. It might contain floats (scales) or integers(sizes). + :param mode: Specifies type of interpolation. Possible values are: nearest, linear, + linear_onnx, cubic, bilinear_pillow, bicubic_pillow. + :param shape_calculation_mode: + Specifies how the scales_or_sizes input should be interpreted. + :param pads_begin: Specifies the number of pixels to add to the beginning of the image + being interpolated. Default is None. + :param pads_end: Specifies the number of pixels to add to the end of the image being + interpolated. Default is None. + :param coordinate_transformation_mode: + Specifies how to transform the coordinate in the resized tensor to the + coordinate in the original tensor. Default is "half_pixel". + :param nearest_mode: Specifies round mode when mode == nearest and is used only when + mode == nearest. Default is "round_prefer_floor". + :param antialias: Specifies whether to perform anti-aliasing. Default is False. + :param cube_coeff: Specifies the parameter a for cubic interpolation. Default is -0.75. + :param axes: 1D tensor specifying dimension indices where interpolation is applied. + The default is None. + :param name: Optional name for the output node. The default is None. + :return: Node representing the interpolation operation. + """ + attrs = { + "mode": mode, + "shape_calculation_mode": shape_calculation_mode, + "coordinate_transformation_mode": coordinate_transformation_mode, + "nearest_mode": nearest_mode, + "antialias": antialias, + "cube_coeff": cube_coeff, + } + + attrs["pads_begin"] = [] if pads_begin is None else pads_begin + attrs["pads_end"] = [] if pads_end is None else pads_end + + inputs = as_nodes(image, scales_or_sizes) if axes is None else as_nodes(image, scales_or_sizes, axes) + + return _get_node_factory_opset11().create("Interpolate", inputs, attrs) diff --git a/src/bindings/python/src/openvino/runtime/utils/node_factory.py b/src/bindings/python/src/openvino/runtime/utils/node_factory.py index a89c05ab0cf..f952bcf90fb 100644 --- a/src/bindings/python/src/openvino/runtime/utils/node_factory.py +++ b/src/bindings/python/src/openvino/runtime/utils/node_factory.py @@ -13,7 +13,7 @@ from openvino.runtime import Node, Output from openvino.runtime.exceptions import UserInputError -DEFAULT_OPSET = "opset10" +DEFAULT_OPSET = "opset11" class NodeFactory(object): diff --git a/src/bindings/python/src/pyopenvino/graph/node_factory.cpp b/src/bindings/python/src/pyopenvino/graph/node_factory.cpp index bdf7c982b3e..9aed62c2e00 100644 --- a/src/bindings/python/src/pyopenvino/graph/node_factory.cpp +++ b/src/bindings/python/src/pyopenvino/graph/node_factory.cpp @@ -79,7 +79,7 @@ private: return it->second(); } - const ov::OpSet& m_opset = ov::get_opset10(); + const ov::OpSet& m_opset = ov::get_opset11(); std::unordered_map> m_variables; }; } // namespace diff --git a/src/bindings/python/tests/test_graph/test_create_op.py b/src/bindings/python/tests/test_graph/test_create_op.py index 120f07562d4..f76ed01641a 100644 --- a/src/bindings/python/tests/test_graph/test_create_op.py +++ b/src/bindings/python/tests/test_graph/test_create_op.py @@ -11,7 +11,8 @@ from openvino.runtime.utils.types import make_constant_node import openvino.runtime.opset1 as ov_opset1 import openvino.runtime.opset5 as ov_opset5 -import openvino.runtime.opset10 as ov +import openvino.runtime.opset10 as ov_opset10 +import openvino.runtime.opset11 as ov from openvino.runtime import Type np_types = [np.float32, np.int32] @@ -2145,8 +2146,29 @@ def test_interpolate_opset10(dtype, expected_shape, shape_calculation_mode): axes = [2, 3] mode = "cubic" - node = ov.interpolate(image=image_node, output_shape=output_shape, scales=scales, - axes=axes, mode=mode, + node = ov_opset10.interpolate(image=image_node, output_shape=output_shape, scales=scales, + axes=axes, mode=mode, shape_calculation_mode=shape_calculation_mode) + assert node.get_type_name() == "Interpolate" + assert node.get_output_size() == 1 + assert list(node.get_output_shape(0)) == expected_shape + + +@pytest.mark.parametrize( + ("expected_shape", "shape_calculation_mode", "input_value"), + [ + ([1, 3, 64, 64], "scales", np.array([1 / 16, 1 / 16], dtype=np.float32)), + ([1, 3, 256, 256], "sizes", np.array([256, 256], dtype=np.int32)), + ], +) +@pytest.mark.parametrize("dtype", np_types) +def test_interpolate_opset11(dtype, expected_shape, shape_calculation_mode, input_value): + + image_shape = [1, 3, 1024, 1024] + image_node = ov.parameter(image_shape, dtype, name="Image") + axes = [2, 3] + mode = "bilinear_pillow" + + node = ov.interpolate(image=image_node, scales_or_sizes=input_value, axes=axes, mode=mode, shape_calculation_mode=shape_calculation_mode) assert node.get_type_name() == "Interpolate" assert node.get_output_size() == 1 diff --git a/src/bindings/python/tests_compatibility/test_ngraph/test_create_op.py b/src/bindings/python/tests_compatibility/test_ngraph/test_create_op.py index 7b084bc77a8..09fda90564b 100644 --- a/src/bindings/python/tests_compatibility/test_ngraph/test_create_op.py +++ b/src/bindings/python/tests_compatibility/test_ngraph/test_create_op.py @@ -11,6 +11,7 @@ import ngraph as ng import ngraph.opset1 as ng_opset1 import ngraph.opset5 as ng_opset5 import ngraph.opset10 as ng_opset10 +import ngraph.opset11 as ng_opset11 from ngraph.utils.types import make_constant_node from ngraph.exceptions import UserInputError from ngraph.impl import Type @@ -2259,13 +2260,33 @@ def test_interpolate_opset10(dtype, expected_shape, shape_calculation_mode): mode = "cubic" node = ng_opset10.interpolate(image=image_node, output_shape=output_shape, scales=scales, - axes=axes, - mode=mode, shape_calculation_mode=shape_calculation_mode) + axes=axes,mode=mode, shape_calculation_mode=shape_calculation_mode) assert node.get_type_name() == "Interpolate" assert node.get_output_size() == 1 assert list(node.get_output_shape(0)) == expected_shape +@pytest.mark.parametrize( + ("expected_shape", "shape_calculation_mode", "input_value"), + [ + ([1, 3, 64, 64], "scales", np.array([1 / 16, 1 / 16], dtype=np.float32)), + ([1, 3, 256, 256], "sizes", np.array([256, 256], dtype=np.int32)), + ], +) +@pytest.mark.parametrize("dtype", np_types) +def test_interpolate_opset11(dtype, expected_shape, shape_calculation_mode, input_value): + + image_shape = [1, 3, 1024, 1024] + image_node = ng.parameter(image_shape, dtype, name="Image") + axes = [2, 3] + mode = "bilinear_pillow" + + node = ng_opset11.interpolate(image=image_node, scales_or_sizes=input_value, axes=axes, mode=mode, + shape_calculation_mode=shape_calculation_mode) + assert node.get_type_name() == "Interpolate" + assert node.get_output_size() == 1 + assert list(node.get_output_shape(0)) == expected_shape + def test_is_finite_opset10(): input_shape = [1, 2, 3, 4] input_node = ng.parameter(input_shape, np.float32, name="InputData")