IntenseWebs/openvino
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[PyOV] Make graph tests hardware agnostic - part 4 (#14705)

Browse Source
This commit is contained in:
Przemyslaw Wysocki 2022-12-21 14:44:20 +01:00 committed by GitHub
parent 9ba9687301
commit cc221679e6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 537 additions and 1377 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/bindings/python/src/compatibility/ngraph/opset4/ops.py
View File

@ -186,7 +186,7 @@ def acosh(node: NodeInput, name: Optional[str] = None) -> Node:
:param name: Optional new name for output node. :param name: Optional new name for output node.
:return: New node with arccosh operation applied on it. :return: New node with arccosh operation applied on it.
""" """
return _get_node_factory_opset4().create("Acosh", [node]) return _get_node_factory_opset4().create("Acosh", as_nodes(node))
@nameable_op @nameable_op
@ -197,7 +197,7 @@ def asinh(node: NodeInput, name: Optional[str] = None) -> Node:
:param name: Optional new name for output node. :param name: Optional new name for output node.
:return: New node with arcsinh operation applied on it. :return: New node with arcsinh operation applied on it.
""" """
return _get_node_factory_opset4().create("Asinh", [node]) return _get_node_factory_opset4().create("Asinh", as_nodes(node))
@nameable_op @nameable_op
@ -208,7 +208,7 @@ def atanh(node: NodeInput, name: Optional[str] = None) -> Node:
:param name: Optional new name for output node. :param name: Optional new name for output node.
:return: New node with arctanh operation applied on it. :return: New node with arctanh operation applied on it.
""" """
return _get_node_factory_opset4().create("Atanh", [node]) return _get_node_factory_opset4().create("Atanh", as_nodes(node))
@nameable_op @nameable_op

2
src/bindings/python/tests_compatibility/__init__.py
View File

@ -44,8 +44,6 @@ xfail_issue_33581 = xfail_test(reason="RuntimeError: nGraph does not support the
"GatherElements") "GatherElements")
xfail_issue_35923 = xfail_test(reason="RuntimeError: PReLU without weights is not supported") xfail_issue_35923 = xfail_test(reason="RuntimeError: PReLU without weights is not supported")
xfail_issue_35927 = xfail_test(reason="RuntimeError: B has zero dimension that is not allowable") xfail_issue_35927 = xfail_test(reason="RuntimeError: B has zero dimension that is not allowable")
xfail_issue_36486 = xfail_test(reason="RuntimeError: HardSigmoid operation should be converted "
"to HardSigmoid_IE")
xfail_issue_38084 = xfail_test(reason="RuntimeError: AssertionFailed: layer->get_output_partial_shape(i)." xfail_issue_38084 = xfail_test(reason="RuntimeError: AssertionFailed: layer->get_output_partial_shape(i)."
"is_static() nGraph <value> operation with name: <value> cannot be " "is_static() nGraph <value> operation with name: <value> cannot be "
"converted to <value> layer with name: <value> because output " "converted to <value> layer with name: <value> because output "

349
src/bindings/python/tests_compatibility/test_ngraph/test_ops.py
View File

@ -6,9 +6,8 @@
import numpy as np import numpy as np
import ngraph as ng import ngraph as ng
from ngraph.impl import AxisSet, Function, Shape, Type from ngraph.impl import AxisSet, Shape, Type
from ngraph.impl.op import Constant, Parameter from ngraph.impl.op import Constant, Parameter
from tests_compatibility.runtime import get_runtime
def binary_op(op_str, a, b): def binary_op(op_str, a, b):
@ -81,47 +80,42 @@ def binary_op_ref(op_str, a, b):
return np.power(a, b) return np.power(a, b)
def binary_op_exec(op_str): def binary_op_exec(op_str, expected_ov_str=None):
if not expected_ov_str:
expected_ov_str = op_str
element_type = Type.f32 element_type = Type.f32
shape = Shape([2, 2]) shape = Shape([2, 2])
A = Parameter(element_type, shape) A = Parameter(element_type, shape)
B = Parameter(element_type, shape) B = Parameter(element_type, shape)
parameter_list = [A, B]
function = Function([binary_op(op_str, A, B)], parameter_list, "test")
a_arr = np.array([[1, 6], [7, 4]], dtype=np.float32) node = binary_op(op_str, A, B)
b_arr = np.array([[5, 2], [3, 8]], dtype=np.float32)
runtime = get_runtime() assert node.get_type_name() == expected_ov_str
computation = runtime.computation(function, A, B) assert node.get_output_size() == 1
result = computation(a_arr, b_arr)[0] assert list(node.get_output_shape(0)) == [2, 2]
assert node.get_output_element_type(0) == Type.f32
expected = binary_op_ref(op_str, a_arr, b_arr)
assert np.allclose(result, expected)
def binary_op_comparison(op_str): def binary_op_comparison(op_str, expected_ov_str=None):
if not expected_ov_str:
expected_ov_str = op_str
element_type = Type.f32 element_type = Type.f32
shape = Shape([2, 2]) shape = Shape([2, 2])
A = Parameter(element_type, shape) A = Parameter(element_type, shape)
B = Parameter(element_type, shape) B = Parameter(element_type, shape)
parameter_list = [A, B]
function = Function([binary_op(op_str, A, B)], parameter_list, "test")
a_arr = np.array([[1, 5], [3, 2]], dtype=np.float32)
b_arr = np.array([[2, 4], [3, 1]], dtype=np.float32)
runtime = get_runtime() node = binary_op(op_str, A, B)
computation = runtime.computation(function, A, B)
result = computation(a_arr, b_arr)[0]
expected = binary_op_ref(op_str, a_arr, b_arr) assert node.get_type_name() == expected_ov_str
assert np.allclose(result, expected) assert node.get_output_size() == 1
assert list(node.get_output_shape(0)) == [2, 2]
assert node.get_output_element_type(0) == Type.boolean
def test_add(): def test_add():
binary_op_exec("+") binary_op_exec("+", "Add")
def test_add_op(): def test_add_op():
@ -129,27 +123,27 @@ def test_add_op():
def test_sub(): def test_sub():
binary_op_exec("-") binary_op_exec("-", "Subtract")
def test_sub_op(): def test_sub_op():
binary_op_exec("Sub") binary_op_exec("Sub", "Subtract")
def test_mul(): def test_mul():
binary_op_exec("*") binary_op_exec("*", "Multiply")
def test_mul_op(): def test_mul_op():
binary_op_exec("Mul") binary_op_exec("Mul", "Multiply")
def test_div(): def test_div():
binary_op_exec("/") binary_op_exec("/", "Divide")
def test_div_op(): def test_div_op():
binary_op_exec("Div") binary_op_exec("Div", "Divide")
def test_maximum(): def test_maximum():
@ -169,7 +163,7 @@ def test_greater():
def test_greater_eq(): def test_greater_eq():
binary_op_comparison("GreaterEq") binary_op_comparison("GreaterEq", "GreaterEqual")
def test_less(): def test_less():
@ -177,7 +171,7 @@ def test_less():
def test_less_eq(): def test_less_eq():
binary_op_comparison("LessEq") binary_op_comparison("LessEq", "LessEqual")
def test_not_equal(): def test_not_equal():
@ -191,23 +185,12 @@ def test_add_with_mul():
A = Parameter(element_type, shape) A = Parameter(element_type, shape)
B = Parameter(element_type, shape) B = Parameter(element_type, shape)
C = Parameter(element_type, shape) C = Parameter(element_type, shape)
parameter_list = [A, B, C] node = ng.multiply(ng.add(A, B), C)
function = Function([ng.multiply(ng.add(A, B), C)], parameter_list, "test")
runtime = get_runtime() assert node.get_type_name() == "Multiply"
computation = runtime.computation(function, A, B, C) assert node.get_output_size() == 1
result = computation( assert list(node.get_output_shape(0)) == [4]
np.array([1, 2, 3, 4], dtype=np.float32), assert node.get_output_element_type(0) == Type.f32
np.array([5, 6, 7, 8], dtype=np.float32),
np.array([9, 10, 11, 12], dtype=np.float32),
)[0]
a_arr = np.array([1, 2, 3, 4], dtype=np.float32)
b_arr = np.array([5, 6, 7, 8], dtype=np.float32)
c_arr = np.array([9, 10, 11, 12], dtype=np.float32)
result_arr_ref = (a_arr + b_arr) * c_arr
assert np.allclose(result, result_arr_ref)
def unary_op(op_str, a): def unary_op(op_str, a):
@ -298,22 +281,21 @@ def unary_op_ref(op_str, a):
return np.tanh(a) return np.tanh(a)
def unary_op_exec(op_str, input_list): def unary_op_exec(op_str, input_list, expected_ov_str=None):
""" """
input_list needs to have deep length of 4 input_list needs to have deep length of 4
""" """
if not expected_ov_str:
expected_ov_str = op_str
element_type = Type.f32 element_type = Type.f32
shape = Shape(np.array(input_list).shape) shape = Shape(np.array(input_list).shape)
A = Parameter(element_type, shape) A = Parameter(element_type, shape)
parameter_list = [A] node = unary_op(op_str, A)
function = Function([unary_op(op_str, A)], parameter_list, "test")
runtime = get_runtime() assert node.get_type_name() == expected_ov_str
computation = runtime.computation(function, *parameter_list) assert node.get_output_size() == 1
result = computation(np.array(input_list, dtype=np.float32))[0] assert list(node.get_output_shape(0)) == list(shape)
assert node.get_output_element_type(0) == Type.f32
expected = unary_op_ref(op_str, np.array(input_list, dtype=np.float32))
assert np.allclose(result, expected)
def test_abs(): def test_abs():
@ -385,19 +367,19 @@ def test_floor():
def test_log(): def test_log():
input_list = [1, 2, 3, 4] input_list = [1, 2, 3, 4]
op_str = "log" op_str = "log"
unary_op_exec(op_str, input_list) unary_op_exec(op_str, input_list, "Log")
def test_exp(): def test_exp():
input_list = [-1, 0, 1, 2] input_list = [-1, 0, 1, 2]
op_str = "exp" op_str = "exp"
unary_op_exec(op_str, input_list) unary_op_exec(op_str, input_list, "Exp")
def test_negative(): def test_negative():
input_list = [-1, 0, 1, 2] input_list = [-1, 0, 1, 2]
op_str = "negative" op_str = "negative"
unary_op_exec(op_str, input_list) unary_op_exec(op_str, input_list, "Negative")
def test_sign(): def test_sign():
@ -441,67 +423,42 @@ def test_reshape():
element_type = Type.f32 element_type = Type.f32
shape = Shape([2, 3]) shape = Shape([2, 3])
A = Parameter(element_type, shape) A = Parameter(element_type, shape)
parameter_list = [A] node = ng.reshape(A, Shape([3, 2]), special_zero=False)
function = Function([ng.reshape(A, Shape([3, 2]), special_zero=False)], parameter_list, "test")
runtime = get_runtime() assert node.get_type_name() == "Reshape"
computation = runtime.computation(function, *parameter_list) assert node.get_output_size() == 1
result = computation(np.array(np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32), dtype=np.float32))[0] assert list(node.get_output_shape(0)) == [3, 2]
assert node.get_output_element_type(0) == element_type
expected = np.reshape(np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32), (3, 2))
assert np.allclose(result, expected)
def test_broadcast(): def test_broadcast():
element_type = Type.f32 element_type = Type.f32
A = Parameter(element_type, Shape([3])) A = Parameter(element_type, Shape([3]))
parameter_list = [A] node = ng.broadcast(A, [3, 3])
function = Function([ng.broadcast(A, [3, 3])], parameter_list, "test") assert node.get_type_name() == "Broadcast"
assert node.get_output_size() == 1
runtime = get_runtime() assert list(node.get_output_shape(0)) == [3, 3]
computation = runtime.computation(function, *parameter_list) assert node.get_output_element_type(0) == element_type
result = computation(np.array([1, 2, 3], dtype=np.float32))[0]
a_arr = np.array([[0], [0], [0]], dtype=np.float32)
b_arr = np.array([[1, 2, 3]], dtype=np.float32)
expected = np.add(a_arr, b_arr)
assert np.allclose(result, expected)
def test_constant(): def test_constant():
element_type = Type.f32 element_type = Type.f32
parameter_list = [] node = Constant(element_type, Shape([3, 3]), list(range(9)))
function = Function([Constant(element_type, Shape([3, 3]), list(range(9)))], parameter_list, "test") assert node.get_type_name() == "Constant"
assert node.get_output_size() == 1
runtime = get_runtime() assert list(node.get_output_shape(0)) == [3, 3]
computation = runtime.computation(function, *parameter_list) assert node.get_output_element_type(0) == element_type
result = computation()[0]
expected = np.arange(9).reshape(3, 3)
assert np.allclose(result, expected)
def test_concat(): def test_concat():
element_type = Type.f32 element_type = Type.f32
A = Parameter(element_type, Shape([1, 2])) node = Constant(element_type, Shape([3, 3]), list(range(9)))
B = Parameter(element_type, Shape([1, 2])) assert node.get_type_name() == "Constant"
C = Parameter(element_type, Shape([1, 2])) assert node.get_output_size() == 1
parameter_list = [A, B, C] assert list(node.get_output_shape(0)) == [3, 3]
axis = 0 assert node.get_output_element_type(0) == element_type
function = Function([ng.concat([A, B, C], axis)], parameter_list, "test")
a_arr = np.array([[1, 2]], dtype=np.float32)
b_arr = np.array([[5, 6]], dtype=np.float32)
c_arr = np.array([[7, 8]], dtype=np.float32)
runtime = get_runtime()
computation = runtime.computation(function, *parameter_list)
result = computation(a_arr, b_arr, c_arr)[0]
expected = np.concatenate((a_arr, b_arr, c_arr), axis)
assert np.allclose(result, expected)
def test_axisset(): def test_axisset():
@ -525,31 +482,18 @@ def test_select():
A = Parameter(Type.boolean, Shape([1, 2])) A = Parameter(Type.boolean, Shape([1, 2]))
B = Parameter(element_type, Shape([1, 2])) B = Parameter(element_type, Shape([1, 2]))
C = Parameter(element_type, Shape([1, 2])) C = Parameter(element_type, Shape([1, 2]))
parameter_list = [A, B, C] node = ng.select(A, B, C)
assert node.get_type_name() == "Select"
function = Function([ng.select(A, B, C)], parameter_list, "test") assert node.get_output_size() == 1
assert list(node.get_output_shape(0)) == [1, 2]
runtime = get_runtime() assert node.get_output_element_type(0) == element_type
computation = runtime.computation(function, *parameter_list)
result = computation(
np.array([[True, False]], dtype=bool),
np.array([[5, 6]], dtype=np.float32),
np.array([[7, 8]], dtype=np.float32),
)[0]
expected = np.array([[5, 8]])
assert np.allclose(result, expected)
def test_max_pool(): def test_max_pool_1d():
# test 1d
element_type = Type.f32 element_type = Type.f32
shape = Shape([1, 1, 10]) shape = Shape([1, 1, 10])
A = Parameter(element_type, shape)
parameter_list = [A]
input_arr = np.arange(10, dtype=np.float32).reshape([1, 1, 10])
window_shape = [3] window_shape = [3]
A = Parameter(element_type, shape)
strides = [1] * len(window_shape) strides = [1] * len(window_shape)
dilations = [1] * len(window_shape) dilations = [1] * len(window_shape)
@ -570,19 +514,26 @@ def test_max_pool():
auto_pad, auto_pad,
idx_elem_type, idx_elem_type,
) )
function = Function([model], parameter_list, "test") assert model.get_type_name() == "MaxPool"
assert model.get_output_size() == 2
assert list(model.get_output_shape(0)) == [1, 1, 8]
assert list(model.get_output_shape(1)) == [1, 1, 8]
assert model.get_output_element_type(0) == element_type
assert model.get_output_element_type(1) == Type.i32
runtime = get_runtime()
computation = runtime.computation(function, *parameter_list)
result = computation(input_arr)[0]
expected = (np.arange(8) + 2).reshape(1, 1, 8) def test_max_pool_1d_with_strides():
assert np.allclose(result, expected) element_type = Type.f32
shape = Shape([1, 1, 10])
# test 1d with strides A = Parameter(element_type, shape)
window_shape = [3]
strides = [2] strides = [2]
pads_begin = [0] * len(window_shape) pads_begin = [0] * len(window_shape)
dilations = [1] * len(window_shape)
pads_end = [0] * len(window_shape) pads_end = [0] * len(window_shape)
rounding_type = "floor"
auto_pad = "explicit"
idx_elem_type = "i32"
model = ng.max_pool( model = ng.max_pool(
A, A,
@ -595,16 +546,15 @@ def test_max_pool():
auto_pad, auto_pad,
idx_elem_type, idx_elem_type,
) )
function = Function([model], parameter_list, "test") assert model.get_type_name() == "MaxPool"
assert model.get_output_size() == 2
assert list(model.get_output_shape(0)) == [1, 1, 4]
assert list(model.get_output_shape(1)) == [1, 1, 4]
assert model.get_output_element_type(0) == element_type
assert model.get_output_element_type(1) == Type.i32
size = 4
computation = runtime.computation(function, *parameter_list)
result = computation(input_arr)[0]
expected = ((np.arange(size) + 1) * 2).reshape(1, 1, size) def test_max_pool_2d():
assert np.allclose(result, expected)
# test 2d
element_type = Type.f32 element_type = Type.f32
shape = Shape([1, 1, 10, 10]) shape = Shape([1, 1, 10, 10])
A = Parameter(element_type, shape) A = Parameter(element_type, shape)
@ -612,6 +562,9 @@ def test_max_pool():
input_arr = np.arange(100, dtype=np.float32).reshape(1, 1, 10, 10) input_arr = np.arange(100, dtype=np.float32).reshape(1, 1, 10, 10)
window_shape = [3, 3] window_shape = [3, 3]
rounding_type = "floor"
auto_pad = "explicit"
idx_elem_type = "i32"
strides = [1, 1] strides = [1, 1]
dilations = [1, 1] dilations = [1, 1]
@ -629,19 +582,26 @@ def test_max_pool():
auto_pad, auto_pad,
idx_elem_type, idx_elem_type,
) )
function = Function([model], parameter_list, "test") assert model.get_type_name() == "MaxPool"
assert model.get_output_size() == 2
assert list(model.get_output_shape(0)) == [1, 1, 8, 8]
assert list(model.get_output_shape(1)) == [1, 1, 8, 8]
assert model.get_output_element_type(0) == element_type
assert model.get_output_element_type(1) == Type.i32
computation = runtime.computation(function, *parameter_list)
result = computation(input_arr)[0]
expected = ((np.arange(100).reshape(10, 10))[2:, 2:]).reshape(1, 1, 8, 8) def test_max_pool_2d_with_strides():
assert np.allclose(result, expected) element_type = Type.f32
shape = Shape([1, 1, 10, 10])
# test 2d with strides A = Parameter(element_type, shape)
strides = [2, 2] strides = [2, 2]
dilations = [1, 1] dilations = [1, 1]
pads_begin = [0, 0] pads_begin = [0, 0]
pads_end = [0, 0] pads_end = [0, 0]
window_shape = [3, 3]
rounding_type = "floor"
auto_pad = "explicit"
idx_elem_type = "i32"
model = ng.max_pool( model = ng.max_pool(
A, A,
@ -654,13 +614,12 @@ def test_max_pool():
auto_pad, auto_pad,
idx_elem_type, idx_elem_type,
) )
function = Function([model], parameter_list, "test") assert model.get_type_name() == "MaxPool"
computation = runtime.computation(function, *parameter_list) assert model.get_output_size() == 2
result = computation(input_arr)[0] assert list(model.get_output_shape(0)) == [1, 1, 4, 4]
assert list(model.get_output_shape(1)) == [1, 1, 4, 4]
size = 4 assert model.get_output_element_type(0) == element_type
expected = ((np.arange(100).reshape(10, 10))[2::2, 2::2]).reshape(1, 1, size, size) assert model.get_output_element_type(1) == Type.i32
assert np.allclose(result, expected)
def convolution2d( def convolution2d(
@ -716,9 +675,6 @@ def test_convolution_simple():
filter_shape = Shape([1, 1, 3, 3]) filter_shape = Shape([1, 1, 3, 3])
data = Parameter(element_type, image_shape) data = Parameter(element_type, image_shape)
filters = Parameter(element_type, filter_shape) filters = Parameter(element_type, filter_shape)
parameter_list = [data, filters]
image_arr = np.arange(-128, 128, 1, dtype=np.float32).reshape(1, 1, 16, 16)
filter_arr = np.ones(9, dtype=np.float32).reshape(1, 1, 3, 3) filter_arr = np.ones(9, dtype=np.float32).reshape(1, 1, 3, 3)
filter_arr[0][0][0][0] = -1 filter_arr[0][0][0][0] = -1
filter_arr[0][0][1][1] = -1 filter_arr[0][0][1][1] = -1
@ -732,14 +688,10 @@ def test_convolution_simple():
dilations = [1, 1] dilations = [1, 1]
model = ng.convolution(data, filters, strides, pads_begin, pads_end, dilations) model = ng.convolution(data, filters, strides, pads_begin, pads_end, dilations)
function = Function([model], parameter_list, "test") assert model.get_type_name() == "Convolution"
assert model.get_output_size() == 1
runtime = get_runtime() assert list(model.get_output_shape(0)) == [1, 1, 14, 14]
computation = runtime.computation(function, *parameter_list) assert model.get_output_element_type(0) == element_type
result = computation(image_arr, filter_arr)[0]
expected = convolution2d(image_arr[0][0], filter_arr[0][0]).reshape(1, 1, 14, 14)
assert np.allclose(result, expected)
def test_convolution_with_strides(): def test_convolution_with_strides():
@ -749,9 +701,6 @@ def test_convolution_with_strides():
filter_shape = Shape([1, 1, 3, 3]) filter_shape = Shape([1, 1, 3, 3])
data = Parameter(element_type, image_shape) data = Parameter(element_type, image_shape)
filters = Parameter(element_type, filter_shape) filters = Parameter(element_type, filter_shape)
parameter_list = [data, filters]
image_arr = np.arange(100, dtype=np.float32).reshape([1, 1, 10, 10])
filter_arr = np.zeros(9, dtype=np.float32).reshape([1, 1, 3, 3]) filter_arr = np.zeros(9, dtype=np.float32).reshape([1, 1, 3, 3])
filter_arr[0][0][1][1] = 1 filter_arr[0][0][1][1] = 1
strides = [2, 2] strides = [2, 2]
@ -760,14 +709,10 @@ def test_convolution_with_strides():
dilations = [1, 1] dilations = [1, 1]
model = ng.convolution(data, filters, strides, pads_begin, pads_end, dilations) model = ng.convolution(data, filters, strides, pads_begin, pads_end, dilations)
function = Function([model], parameter_list, "test") assert model.get_type_name() == "Convolution"
assert model.get_output_size() == 1
runtime = get_runtime() assert list(model.get_output_shape(0)) == [1, 1, 4, 4]
computation = runtime.computation(function, *parameter_list) assert model.get_output_element_type(0) == element_type
result = computation(image_arr, filter_arr)[0]
expected = convolution2d(image_arr[0][0], filter_arr[0][0], strides).reshape(1, 1, 4, 4)
assert np.allclose(result, expected)
def test_convolution_with_filter_dilation(): def test_convolution_with_filter_dilation():
@ -777,24 +722,16 @@ def test_convolution_with_filter_dilation():
filter_shape = Shape([1, 1, 3, 3]) filter_shape = Shape([1, 1, 3, 3])
data = Parameter(element_type, image_shape) data = Parameter(element_type, image_shape)
filters = Parameter(element_type, filter_shape) filters = Parameter(element_type, filter_shape)
parameter_list = [data, filters]
image_arr = np.arange(100, dtype=np.float32).reshape([1, 1, 10, 10])
filter_arr = np.ones(9, dtype=np.float32).reshape([1, 1, 3, 3])
strides = [1, 1] strides = [1, 1]
pads_begin = [0, 0] pads_begin = [0, 0]
pads_end = [0, 0] pads_end = [0, 0]
dilations = [2, 2] dilations = [2, 2]
model = ng.convolution(data, filters, strides, pads_begin, pads_end, dilations) model = ng.convolution(data, filters, strides, pads_begin, pads_end, dilations)
function = Function([model], parameter_list, "test") assert model.get_type_name() == "Convolution"
assert model.get_output_size() == 1
runtime = get_runtime() assert list(model.get_output_shape(0)) == [1, 1, 6, 6]
computation = runtime.computation(function, *parameter_list) assert model.get_output_element_type(0) == element_type
result = computation(image_arr, filter_arr)[0]
expected = convolution2d(image_arr[0][0], filter_arr[0][0], strides, dilations).reshape([1, 1, 6, 6])
assert np.allclose(result, expected)
def test_convolution_with_padding(): def test_convolution_with_padding():
@ -804,9 +741,6 @@ def test_convolution_with_padding():
filter_shape = Shape([1, 1, 3, 3]) filter_shape = Shape([1, 1, 3, 3])
data = Parameter(element_type, image_shape) data = Parameter(element_type, image_shape)
filters = Parameter(element_type, filter_shape) filters = Parameter(element_type, filter_shape)
parameter_list = [data, filters]
image_arr = np.arange(100, dtype=np.float32).reshape(1, 1, 10, 10)
filter_arr = np.zeros(9, dtype=np.float32).reshape(1, 1, 3, 3) filter_arr = np.zeros(9, dtype=np.float32).reshape(1, 1, 3, 3)
filter_arr[0][0][1][1] = 1 filter_arr[0][0][1][1] = 1
strides = [1, 1] strides = [1, 1]
@ -815,16 +749,10 @@ def test_convolution_with_padding():
pads_end = [0, 0] pads_end = [0, 0]
model = ng.convolution(data, filters, strides, pads_begin, pads_end, dilations) model = ng.convolution(data, filters, strides, pads_begin, pads_end, dilations)
function = Function([model], parameter_list, "test") assert model.get_type_name() == "Convolution"
assert model.get_output_size() == 1
runtime = get_runtime() assert list(model.get_output_shape(0)) == [1, 1, 6, 6]
computation = runtime.computation(function, *parameter_list) assert model.get_output_element_type(0) == element_type
result = computation(image_arr, filter_arr)[0]
expected = convolution2d(
image_arr[0][0], filter_arr[0][0], strides, dilations, pads_begin, pads_end
).reshape([1, 1, 6, 6])
assert np.allclose(result, expected)
def test_convolution_with_non_zero_padding(): def test_convolution_with_non_zero_padding():
@ -833,9 +761,6 @@ def test_convolution_with_non_zero_padding():
filter_shape = Shape([1, 1, 3, 3]) filter_shape = Shape([1, 1, 3, 3])
data = Parameter(element_type, image_shape) data = Parameter(element_type, image_shape)
filters = Parameter(element_type, filter_shape) filters = Parameter(element_type, filter_shape)
parameter_list = [data, filters]
image_arr = np.arange(100, dtype=np.float32).reshape(1, 1, 10, 10)
filter_arr = (np.ones(9, dtype=np.float32).reshape(1, 1, 3, 3)) * -1 filter_arr = (np.ones(9, dtype=np.float32).reshape(1, 1, 3, 3)) * -1
filter_arr[0][0][1][1] = 1 filter_arr[0][0][1][1] = 1
strides = [1, 1] strides = [1, 1]
@ -844,13 +769,7 @@ def test_convolution_with_non_zero_padding():
pads_end = [1, 2] pads_end = [1, 2]
model = ng.convolution(data, filters, strides, pads_begin, pads_end, dilations) model = ng.convolution(data, filters, strides, pads_begin, pads_end, dilations)
function = Function([model], parameter_list, "test") assert model.get_type_name() == "Convolution"
assert model.get_output_size() == 1
runtime = get_runtime() assert list(model.get_output_shape(0)) == [1, 1, 9, 9]
computation = runtime.computation(function, *parameter_list) assert model.get_output_element_type(0) == element_type
result = computation(image_arr, filter_arr)[0]
expected = convolution2d(
image_arr[0][0], filter_arr[0][0], strides, dilations, pads_begin, pads_end
).reshape([1, 1, 9, 9])
assert np.allclose(result, expected)

9
src/bindings/python/tests_compatibility/test_ngraph/test_ops_binary.py
View File

@ -74,7 +74,7 @@ def test_binary_op(ng_api_helper, expected_type):
"ng_api_helper", "ng_api_helper",
[ng.logical_and, ng.logical_or, ng.logical_xor], [ng.logical_and, ng.logical_or, ng.logical_xor],
) )
def test_binary_logical_op(ng_api_helper): def test_binary_logical_op_parameter_inputs(ng_api_helper):
shape = [2, 2] shape = [2, 2]
parameter_a = ng.parameter(shape, name="A", dtype=bool) parameter_a = ng.parameter(shape, name="A", dtype=bool)
parameter_b = ng.parameter(shape, name="B", dtype=bool) parameter_b = ng.parameter(shape, name="B", dtype=bool)
@ -89,8 +89,8 @@ def test_binary_logical_op(ng_api_helper):
"ng_api_helper", "ng_api_helper",
[ng.logical_and, ng.logical_or, ng.logical_xor], [ng.logical_and, ng.logical_or, ng.logical_xor],
) )
def test_binary_logical_op_with_scalar(ng_api_helper): def test_binary_logical_numpy_input(ng_api_helper):
value_b = np.array([[False, True], [False, True]], dtype=bool) value_b = np.array([[False, True], [False, True]], dtype=np.bool)
shape = [2, 2] shape = [2, 2]
parameter_a = ng.parameter(shape, name="A", dtype=bool) parameter_a = ng.parameter(shape, name="A", dtype=bool)
@ -98,6 +98,7 @@ def test_binary_logical_op_with_scalar(ng_api_helper):
model = ng_api_helper(parameter_a, value_b) model = ng_api_helper(parameter_a, value_b)
assert model.get_output_size() == 1 assert model.get_output_size() == 1
assert list(model.get_output_shape(0)) == [2, 2] assert list(model.get_output_shape(0)) == [2, 2]
assert model.get_output_element_type(0) == Type.boolean
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -143,7 +144,7 @@ def test_binary_operators(operator, expected_type):
], ],
) )
def test_binary_operators_with_scalar(operator, expected_type): def test_binary_operators_with_scalar(operator, expected_type):
value_b = np.array([[5, 6], [7, 8]], dtype=np.float32) value_b = np.array(3, dtype=np.float32)
shape = [2, 2] shape = [2, 2]
parameter_a = ng.parameter(shape, name="A", dtype=np.float32) parameter_a = ng.parameter(shape, name="A", dtype=np.float32)

592
src/bindings/python/tests_compatibility/test_ngraph/test_ops_fused.py
View File

@ -2,52 +2,37 @@
# SPDX-License-Identifier: Apache-2.0 # SPDX-License-Identifier: Apache-2.0
import numpy as np import numpy as np
import pytest
import ngraph as ng import ngraph as ng
from tests_compatibility.runtime import get_runtime from ngraph.impl import Type
from tests_compatibility import xfail_issue_36486
def test_elu_operator_with_scalar_and_array(): def test_elu_operator_with_scalar_and_array():
runtime = get_runtime() data_value = ng.parameter((2, 2), name="data_value", dtype=np.float32)
data_value = np.array([[-5, 1], [-2, 3]], dtype=np.float32)
alpha_value = np.float32(3) alpha_value = np.float32(3)
model = ng.elu(data_value, alpha_value) model = ng.elu(data_value, alpha_value)
computation = runtime.computation(model) assert model.get_type_name() == "Elu"
assert model.get_output_size() == 1
result = computation() assert list(model.get_output_shape(0)) == [2, 2]
expected = np.array([[-2.9797862, 1.0], [-2.5939941, 3.0]], dtype=np.float32) assert model.get_output_element_type(0) == Type.f32
assert np.allclose(result, expected)
def test_elu_operator_with_scalar(): def test_elu_operator_with_scalar():
runtime = get_runtime() parameter_data = ng.parameter([2, 2], name="Data", dtype=np.float32)
data_value = np.array([[-5, 1], [-2, 3]], dtype=np.float32)
alpha_value = np.float32(3) alpha_value = np.float32(3)
data_shape = [2, 2] data_shape = [2, 2]
parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32) parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32)
model = ng.elu(parameter_data, alpha_value) model = ng.elu(parameter_data, alpha_value)
computation = runtime.computation(model, parameter_data) assert model.get_type_name() == "Elu"
assert model.get_output_size() == 1
result = computation(data_value) assert list(model.get_output_shape(0)) == [2, 2]
expected = np.array([[-2.9797862, 1.0], [-2.5939941, 3.0]], dtype=np.float32) assert model.get_output_element_type(0) == Type.f32
assert np.allclose(result, expected)
def test_fake_quantize(): def test_fake_quantize():
runtime = get_runtime()
data_value = np.arange(24.0, dtype=np.float32).reshape(1, 2, 3, 4)
input_low_value = np.float32(0)
input_high_value = np.float32(23)
output_low_value = np.float32(2)
output_high_value = np.float32(16)
levels = np.float32(4) levels = np.float32(4)
data_shape = [1, 2, 3, 4] data_shape = [1, 2, 3, 4]
@ -66,74 +51,29 @@ def test_fake_quantize():
parameter_output_high, parameter_output_high,
levels, levels,
) )
computation = runtime.computation( assert model.get_type_name() == "FakeQuantize"
model, assert model.get_output_size() == 1
parameter_data, assert list(model.get_output_shape(0)) == [1, 2, 3, 4]
parameter_input_low, assert model.get_output_element_type(0) == Type.f32
parameter_input_high,
parameter_output_low,
parameter_output_high,
)
result = computation(data_value, input_low_value, input_high_value, output_low_value, output_high_value)
expected = np.array(
[
[
[
[
[2.0, 2.0, 2.0, 2.0],
[6.6666669, 6.6666669, 6.6666669, 6.6666669],
[6.6666669, 6.6666669, 6.6666669, 6.6666669],
],
[
[11.33333301, 11.33333301, 11.33333301, 11.33333301],
[11.33333301, 11.33333301, 11.33333301, 11.33333301],
[16.0, 16.0, 16.0, 16.0],
],
]
]
],
dtype=np.float32,
)
assert np.allclose(result, expected)
def test_depth_to_space(): def test_depth_to_space():
runtime = get_runtime() data_shape = [1, 4, 2, 3]
data_value = np.array(
[
[
[[0, 1, 2], [3, 4, 5]],
[[6, 7, 8], [9, 10, 11]],
[[12, 13, 14], [15, 16, 17]],
[[18, 19, 20], [21, 22, 23]],
]
],
dtype=np.float32,
)
mode = "blocks_first" mode = "blocks_first"
block_size = np.float32(2) block_size = np.float32(2)
data_shape = [1, 4, 2, 3]
parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32) parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32)
model = ng.depth_to_space(parameter_data, mode, block_size) model = ng.depth_to_space(parameter_data, mode, block_size)
computation = runtime.computation(model, parameter_data) assert model.get_type_name() == "DepthToSpace"
assert model.get_output_size() == 1
result = computation(data_value) assert list(model.get_output_shape(0)) == [1, 1, 4, 6]
expected = np.array( assert model.get_output_element_type(0) == Type.f32
[[[[0, 6, 1, 7, 2, 8], [12, 18, 13, 19, 14, 20], [3, 9, 4, 10, 5, 11], [15, 21, 16, 22, 17, 23]]]],
dtype=np.float32,
)
assert np.allclose(result, expected)
def test_space_to_batch(): def test_space_to_batch():
runtime = get_runtime()
data_value = np.array([[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]], dtype=np.float32) data_value = np.array([[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]], dtype=np.float32)
data_shape = [1, 2, 2, 3]
data_shape = data_value.shape data_shape = data_value.shape
block_shape = np.array([1, 2, 3, 2], dtype=np.int64) block_shape = np.array([1, 2, 3, 2], dtype=np.int64)
@ -143,50 +83,14 @@ def test_space_to_batch():
parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32) parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32)
model = ng.space_to_batch(parameter_data, block_shape, pads_begin, pads_end) model = ng.space_to_batch(parameter_data, block_shape, pads_begin, pads_end)
computation = runtime.computation(model, parameter_data) assert model.get_type_name() == "SpaceToBatch"
assert model.get_output_size() == 1
result = computation(data_value) assert list(model.get_output_shape(0)) == [12, 1, 1, 2]
expected = np.array( assert model.get_output_element_type(0) == Type.f32
[
[[[0, 0]]],
[[[0, 0]]],
[[[0, 2]]],
[[[1, 0]]],
[[[3, 5]]],
[[[4, 0]]],
[[[0, 0]]],
[[[0, 0]]],
[[[6, 8]]],
[[[7, 0]]],
[[[9, 11]]],
[[[10, 0]]],
],
dtype=np.float32,
)
assert np.allclose(result, expected)
def test_batch_to_space(): def test_batch_to_space():
runtime = get_runtime() data_shape = [12, 1, 1, 2]
data = np.array(
[
[[[0, 0]]],
[[[0, 0]]],
[[[0, 2]]],
[[[1, 0]]],
[[[3, 5]]],
[[[4, 0]]],
[[[0, 0]]],
[[[0, 0]]],
[[[6, 8]]],
[[[7, 0]]],
[[[9, 11]]],
[[[10, 0]]],
],
dtype=np.float32,
)
data_shape = data.shape
block_shape = np.array([1, 2, 3, 2], dtype=np.int64) block_shape = np.array([1, 2, 3, 2], dtype=np.int64)
crops_begin = np.array([0, 0, 1, 0], dtype=np.int64) crops_begin = np.array([0, 0, 1, 0], dtype=np.int64)
@ -195,142 +99,89 @@ def test_batch_to_space():
parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32) parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32)
model = ng.batch_to_space(parameter_data, block_shape, crops_begin, crops_end) model = ng.batch_to_space(parameter_data, block_shape, crops_begin, crops_end)
computation = runtime.computation(model, parameter_data) assert model.get_type_name() == "BatchToSpace"
assert model.get_output_size() == 1
result = computation(data) assert list(model.get_output_shape(0)) == [1, 2, 2, 3]
expected = np.array([[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]], dtype=np.float32) assert model.get_output_element_type(0) == Type.f32
assert np.allclose(result, expected)
def test_clamp_operator(): def test_clamp_operator():
runtime = get_runtime()
data_shape = [2, 2] data_shape = [2, 2]
parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32) parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32)
min_value = np.float32(3) min_value = np.float32(3)
max_value = np.float32(12) max_value = np.float32(12)
model = ng.clamp(parameter_data, min_value, max_value) model = ng.clamp(parameter_data, min_value, max_value)
computation = runtime.computation(model, parameter_data) assert model.get_type_name() == "Clamp"
assert model.get_output_size() == 1
data_value = np.array([[-5, 9], [45, 3]], dtype=np.float32) assert list(model.get_output_shape(0)) == [2, 2]
assert model.get_output_element_type(0) == Type.f32
result = computation(data_value)
expected = np.clip(data_value, min_value, max_value)
assert np.allclose(result, expected)
def test_clamp_operator_with_array(): def test_clamp_operator_with_array():
runtime = get_runtime()
data_value = np.array([[-5, 9], [45, 3]], dtype=np.float32) data_value = np.array([[-5, 9], [45, 3]], dtype=np.float32)
min_value = np.float32(3) min_value = np.float32(3)
max_value = np.float32(12) max_value = np.float32(12)
model = ng.clamp(data_value, min_value, max_value) model = ng.clamp(data_value, min_value, max_value)
computation = runtime.computation(model) assert model.get_type_name() == "Clamp"
assert model.get_output_size() == 1
result = computation() assert list(model.get_output_shape(0)) == [2, 2]
expected = np.clip(data_value, min_value, max_value) assert model.get_output_element_type(0) == Type.f32
assert np.allclose(result, expected)
def test_squeeze_operator(): def test_squeeze_operator():
runtime = get_runtime()
data_shape = [1, 2, 1, 3, 1, 1] data_shape = [1, 2, 1, 3, 1, 1]
parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32) parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32)
data_value = np.arange(6.0, dtype=np.float32).reshape([1, 2, 1, 3, 1, 1])
axes = [2, 4] axes = [2, 4]
model = ng.squeeze(parameter_data, axes) model = ng.squeeze(parameter_data, axes)
computation = runtime.computation(model, parameter_data) assert model.get_type_name() == "Squeeze"
assert model.get_output_size() == 1
result = computation(data_value) assert list(model.get_output_shape(0)) == [1, 2, 3, 1]
expected = np.arange(6.0, dtype=np.float32).reshape([1, 2, 3, 1]) assert model.get_output_element_type(0) == Type.f32
assert np.allclose(result, expected)
def test_squared_difference_operator(): def test_squared_difference_operator():
runtime = get_runtime()
x1_shape = [1, 2, 3, 4] x1_shape = [1, 2, 3, 4]
x2_shape = [2, 3, 4] x2_shape = [2, 3, 4]
parameter_x1 = ng.parameter(x1_shape, name="x1", dtype=np.float32) parameter_x1 = ng.parameter(x1_shape, name="x1", dtype=np.float32)
parameter_x2 = ng.parameter(x2_shape, name="x2", dtype=np.float32) parameter_x2 = ng.parameter(x2_shape, name="x2", dtype=np.float32)
x1_value = np.arange(24.0, dtype=np.float32).reshape(x1_shape)
x2_value = np.arange(start=4.0, stop=28.0, step=1.0, dtype=np.float32).reshape(x2_shape)
model = ng.squared_difference(parameter_x1, parameter_x2) model = ng.squared_difference(parameter_x1, parameter_x2)
computation = runtime.computation(model, parameter_x1, parameter_x2) assert model.get_type_name() == "SquaredDifference"
assert model.get_output_size() == 1
result = computation(x1_value, x2_value) assert model.get_output_element_type(0) == Type.f32
expected = np.square(np.subtract(x1_value, x2_value)) assert list(model.get_output_shape(0)) == [1, 2, 3, 4]
assert np.allclose(result, expected)
def test_shuffle_channels_operator(): def test_shuffle_channels_operator():
runtime = get_runtime()
data_shape = [1, 15, 2, 2] data_shape = [1, 15, 2, 2]
axis = 1 axis = 1
groups = 5 groups = 5
parameter = ng.parameter(data_shape, name="Data", dtype=np.float32) parameter = ng.parameter(data_shape, name="Data", dtype=np.float32)
data_value = np.arange(60.0, dtype=np.float32).reshape(data_shape)
model = ng.shuffle_channels(parameter, axis, groups) model = ng.shuffle_channels(parameter, axis, groups)
computation = runtime.computation(model, parameter) assert model.get_type_name() == "ShuffleChannels"
assert model.get_output_size() == 1
result = computation(data_value) assert model.get_output_element_type(0) == Type.f32
expected = np.array( assert list(model.get_output_shape(0)) == [1, 15, 2, 2]
[
[
[[0.0, 1.0], [2.0, 3.0]],
[[12.0, 13.0], [14.0, 15.0]],
[[24.0, 25.0], [26.0, 27.0]],
[[36.0, 37.0], [38.0, 39.0]],
[[48.0, 49.0], [50.0, 51.0]],
[[4.0, 5.0], [6.0, 7.0]],
[[16.0, 17.0], [18.0, 19.0]],
[[28.0, 29.0], [30.0, 31.0]],
[[40.0, 41.0], [42.0, 43.0]],
[[52.0, 53.0], [54.0, 55.0]],
[[8.0, 9.0], [10.0, 11.0]],
[[20.0, 21.0], [22.0, 23.0]],
[[32.0, 33.0], [34.0, 35.0]],
[[44.0, 45.0], [46.0, 47.0]],
[[56.0, 57.0], [58.0, 59.0]],
]
],
dtype=np.float32,
)
assert np.allclose(result, expected)
def test_unsqueeze(): def test_unsqueeze():
runtime = get_runtime()
data_shape = [3, 4, 5] data_shape = [3, 4, 5]
parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32) parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32)
data_value = np.arange(60.0, dtype=np.float32).reshape(3, 4, 5)
axes = [0, 4] axes = [0, 4]
model = ng.unsqueeze(parameter_data, axes) model = ng.unsqueeze(parameter_data, axes)
computation = runtime.computation(model, parameter_data) assert model.get_type_name() == "Unsqueeze"
assert model.get_output_size() == 1
result = computation(data_value) assert model.get_output_element_type(0) == Type.f32
expected = np.arange(60.0, dtype=np.float32).reshape([1, 3, 4, 5, 1]) assert list(model.get_output_shape(0)) == [1, 3, 4, 5, 1]
assert np.allclose(result, expected)
def test_grn_operator(): def test_grn_operator():
runtime = get_runtime()
data_value = np.arange(start=1.0, stop=25.0, dtype=np.float32).reshape([1, 2, 3, 4])
bias = np.float32(1e-6) bias = np.float32(1e-6)
data_shape = [1, 2, 3, 4] data_shape = [1, 2, 3, 4]
@ -338,202 +189,82 @@ def test_grn_operator():
parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32) parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32)
model = ng.grn(parameter_data, bias) model = ng.grn(parameter_data, bias)
computation = runtime.computation(model, parameter_data) assert model.get_type_name() == "GRN"
assert model.get_output_size() == 1
result = computation(data_value) assert model.get_output_element_type(0) == Type.f32
expected = np.array( assert list(model.get_output_shape(0)) == data_shape
[
[
[
[0.0766965, 0.14142136, 0.19611613, 0.24253564],
[0.28216633, 0.31622776, 0.34570536, 0.37139067],
[0.39391932, 0.41380295, 0.4314555, 0.4472136],
],
[
[0.9970545, 0.98994946, 0.9805807, 0.97014254],
[0.9593655, 0.9486833, 0.9383431, 0.9284767],
[0.91914505, 0.9103665, 0.9021342, 0.8944272],
],
]
],
dtype=np.float32,
)
assert np.allclose(result, expected)
def test_prelu_operator(): def test_prelu_operator():
runtime = get_runtime()
data_shape = [1, 2, 3, 4] data_shape = [1, 2, 3, 4]
slope_shape = [2, 3, 1] slope_shape = [2, 3, 1]
data_value = np.arange(start=1.0, stop=25.0, dtype=np.float32).reshape(data_shape)
slope_value = np.arange(start=-10.0, stop=-4.0, dtype=np.float32).reshape(slope_shape)
parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32) parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32)
parameter_slope = ng.parameter(slope_shape, name="Slope", dtype=np.float32) parameter_slope = ng.parameter(slope_shape, name="Slope", dtype=np.float32)
model = ng.prelu(parameter_data, parameter_slope) model = ng.prelu(parameter_data, parameter_slope)
computation = runtime.computation(model, parameter_data, parameter_slope) assert model.get_type_name() == "PRelu"
assert model.get_output_size() == 1
result = computation(data_value, slope_value) assert model.get_output_element_type(0) == Type.f32
expected = np.clip(data_value, 0, np.inf) + np.clip(data_value, -np.inf, 0) * slope_value assert list(model.get_output_shape(0)) == [1, 2, 3, 4]
assert np.allclose(result, expected)
def test_selu_operator(): def test_selu_operator():
runtime = get_runtime()
data_shape = [4, 2, 3, 1] data_shape = [4, 2, 3, 1]
data = np.arange(start=1.0, stop=25.0, dtype=np.float32).reshape(data_shape)
alpha = np.array(1.6733, dtype=np.float32) alpha = np.array(1.6733, dtype=np.float32)
lambda_value = np.array(1.0507, dtype=np.float32) lambda_value = np.array(1.0507, dtype=np.float32)
parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32) parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32)
model = ng.selu(parameter_data, alpha, lambda_value) model = ng.selu(parameter_data, alpha, lambda_value)
computation = runtime.computation(model, parameter_data) assert model.get_type_name() == "Selu"
assert model.get_output_size() == 1
result = computation(data) assert model.get_output_element_type(0) == Type.f32
expected = lambda_value * ((data > 0) * data + (data <= 0) * (alpha * np.exp(data) - alpha)) assert list(model.get_output_shape(0)) == [4, 2, 3, 1]
assert np.allclose(result, expected)
@xfail_issue_36486
def test_hard_sigmoid_operator(): def test_hard_sigmoid_operator():
runtime = get_runtime()
data_shape = [3] data_shape = [3]
alpha_value = np.float32(0.5)
beta_value = np.float32(0.6)
data_value = np.array([-1, 0, 1], dtype=np.float32)
parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32) parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32)
parameter_alpha = ng.parameter([], name="Alpha", dtype=np.float32) parameter_alpha = ng.parameter([], name="Alpha", dtype=np.float32)
parameter_beta = ng.parameter([], name="Beta", dtype=np.float32) parameter_beta = ng.parameter([], name="Beta", dtype=np.float32)
model = ng.hard_sigmoid(parameter_data, parameter_alpha, parameter_beta) model = ng.hard_sigmoid(parameter_data, parameter_alpha, parameter_beta)
computation = runtime.computation(model, parameter_data, parameter_alpha, parameter_beta) assert model.get_type_name() == "HardSigmoid"
assert model.get_output_size() == 1
result = computation(data_value, alpha_value, beta_value) assert model.get_output_element_type(0) == Type.f32
expected = [0.1, 0.6, 1.0] assert list(model.get_output_shape(0)) == [3]
assert np.allclose(result, expected)
def test_mvn_operator(): def test_mvn_operator():
runtime = get_runtime()
data_shape = [3, 3, 3, 1] data_shape = [3, 3, 3, 1]
axes = [0, 2, 3] axes = [0, 2, 3]
normalize_variance = True normalize_variance = True
eps = np.float32(1e-9) eps = np.float32(1e-9)
eps_mode = "outside_sqrt" eps_mode = "outside_sqrt"
data_value = np.array(
[
[
[[0.8439683], [0.5665144], [0.05836735]],
[[0.02916367], [0.12964272], [0.5060197]],
[[0.79538304], [0.9411346], [0.9546573]],
],
[
[[0.17730942], [0.46192095], [0.26480448]],
[[0.6746842], [0.01665257], [0.62473077]],
[[0.9240844], [0.9722341], [0.11965699]],
],
[
[[0.41356155], [0.9129373], [0.59330076]],
[[0.81929934], [0.7862604], [0.11799799]],
[[0.69248444], [0.54119414], [0.07513223]],
],
],
dtype=np.float32,
)
parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32) parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32)
model = ng.mvn(parameter_data, axes, normalize_variance, eps, eps_mode) model = ng.mvn(parameter_data, axes, normalize_variance, eps, eps_mode)
computation = runtime.computation(model, parameter_data) assert model.get_type_name() == "MVN"
assert model.get_output_size() == 1
result = computation(data_value) assert model.get_output_element_type(0) == Type.f32
assert list(model.get_output_shape(0)) == data_shape
expected = np.array(
[
[
[[1.3546423], [0.33053496], [-1.5450814]],
[[-1.2106764], [-0.8925952], [0.29888135]],
[[0.38083088], [0.81808794], [0.85865635]],
],
[
[[-1.1060555], [-0.05552877], [-0.78310335]],
[[0.83281356], [-1.250282], [0.67467856]],
[[0.7669372], [0.9113869], [-1.6463585]],
],
[
[[-0.23402764], [1.6092131], [0.42940593]],
[[1.2906139], [1.1860244], [-0.92945826]],
[[0.0721334], [-0.38174], [-1.7799333]],
],
],
dtype=np.float32,
)
assert np.allclose(result, expected)
def test_space_to_depth_operator(): def test_space_to_depth_operator():
runtime = get_runtime()
data_shape = [1, 2, 4, 4] data_shape = [1, 2, 4, 4]
data_value = np.arange(start=0, stop=32, step=1.0, dtype=np.float32).reshape(data_shape)
mode = "blocks_first" mode = "blocks_first"
block_size = 2 block_size = 2
parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32) parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32)
model = ng.space_to_depth(parameter_data, mode, block_size) model = ng.space_to_depth(parameter_data, mode, block_size)
computation = runtime.computation(model, parameter_data) assert model.get_type_name() == "SpaceToDepth"
assert model.get_output_size() == 1
result = computation(data_value) assert model.get_output_element_type(0) == Type.f32
expected = np.array( assert list(model.get_output_shape(0)) == [1, 8, 2, 2]
[
0,
2,
8,
10,
16,
18,
24,
26,
1,
3,
9,
11,
17,
19,
25,
27,
4,
6,
12,
14,
20,
22,
28,
30,
5,
7,
13,
15,
21,
23,
29,
31,
],
dtype=np.float32,
).reshape(1, 8, 2, 2)
assert np.allclose(result, expected)
batch_size = 2 batch_size = 2
input_size = 3 input_size = 3
@ -551,41 +282,6 @@ def test_space_to_depth_operator():
parameter_R = ng.parameter(R_shape, name="R", dtype=np.float32) parameter_R = ng.parameter(R_shape, name="R", dtype=np.float32)
parameter_B = ng.parameter(B_shape, name="B", dtype=np.float32) parameter_B = ng.parameter(B_shape, name="B", dtype=np.float32)
X_value = np.array(
[0.3432185, 0.612268, 0.20272376, 0.9513413, 0.30585995, 0.7265472], dtype=np.float32
).reshape(X_shape)
H_t_value = np.array(
[0.12444675, 0.52055854, 0.46489045, 0.4983964, 0.7730452, 0.28439692], dtype=np.float32
).reshape(H_t_shape)
W_value = np.array(
[
0.41930267,
0.7872176,
0.89940447,
0.23659843,
0.24676207,
0.17101714,
0.3147149,
0.6555601,
0.4559603,
],
dtype=np.float32,
).reshape(W_shape)
R_value = np.array(
[
0.8374871,
0.86660194,
0.82114047,
0.71549815,
0.18775631,
0.3182116,
0.25392973,
0.38301638,
0.85531586,
],
dtype=np.float32,
).reshape(R_shape)
B_value = np.array([1.0289404, 1.6362579, 0.4370661], dtype=np.float32).reshape(B_shape)
activations = ["sigmoid"] activations = ["sigmoid"]
activation_alpha = [] activation_alpha = []
activation_beta = [] activation_beta = []
@ -603,47 +299,32 @@ def test_space_to_depth_operator():
activation_beta, activation_beta,
clip, clip,
) )
computation = runtime.computation( assert model.get_type_name() == "RNNCell"
model, parameter_X, parameter_H_t, parameter_W, parameter_R, parameter_B assert model.get_output_size() == 1
) assert model.get_output_element_type(0) == Type.f32
assert list(model.get_output_shape(0)) == [batch_size, hidden_size]
result = computation(X_value, H_t_value, W_value, R_value, B_value)
expected = np.array(
[0.94126844, 0.9036043, 0.841243, 0.9468489, 0.934215, 0.873708], dtype=np.float32
).reshape(batch_size, hidden_size)
assert np.allclose(result, expected)
def test_group_convolution_operator(): def test_group_convolution_operator():
runtime = get_runtime()
data_shape = [1, 4, 2, 2] data_shape = [1, 4, 2, 2]
filters_shape = [2, 1, 2, 1, 1] filters_shape = [2, 1, 2, 1, 1]
parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32) parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32)
parameter_filters = ng.parameter(filters_shape, name="Filters", dtype=np.float32) parameter_filters = ng.parameter(filters_shape, name="Filters", dtype=np.float32)
data_value = np.arange(start=1.0, stop=17.0, dtype=np.float32).reshape(data_shape)
filters_value = np.arange(start=1.0, stop=5.0, dtype=np.float32).reshape(filters_shape)
strides = [1, 1] strides = [1, 1]
dilations = [1, 1] dilations = [1, 1]
pads_begin = [0, 0] pads_begin = [0, 0]
pads_end = [0, 0] pads_end = [0, 0]
model = ng.group_convolution(parameter_data, parameter_filters, strides, pads_begin, pads_end, dilations) model = ng.group_convolution(parameter_data, parameter_filters, strides, pads_begin, pads_end, dilations)
computation = runtime.computation(model, parameter_data, parameter_filters) assert model.get_type_name() == "GroupConvolution"
result = computation(data_value, filters_value) assert model.get_output_size() == 1
assert model.get_output_element_type(0) == Type.f32
expected = np.array([11, 14, 17, 20, 79, 86, 93, 100], dtype=np.float32).reshape(1, 2, 2, 2) assert list(model.get_output_shape(0)) == [1, 2, 2, 2]
assert np.allclose(result, expected)
@pytest.mark.xfail(reason="Computation mismatch")
def test_group_convolution_backprop_data(): def test_group_convolution_backprop_data():
runtime = get_runtime()
data_shape = [1, 1, 3, 3] data_shape = [1, 1, 3, 3]
filters_shape = [1, 1, 1, 3, 3] filters_shape = [1, 1, 1, 3, 3]
strides = [2, 2] strides = [2, 2]
@ -657,87 +338,13 @@ def test_group_convolution_backprop_data():
data_node, filters_node, strides, None, pads_begin, pads_end, output_padding=output_padding data_node, filters_node, strides, None, pads_begin, pads_end, output_padding=output_padding
) )
data_value = np.array( assert model.get_type_name() == "GroupConvolutionBackpropData"
[ assert model.get_output_size() == 1
0.16857791, assert model.get_output_element_type(0) == Type.f32
-0.15161794, assert list(model.get_output_shape(0)) == [1, 1, 6, 6]
0.08540368,
0.1820628,
-0.21746576,
0.08245695,
0.1431433,
-0.43156421,
0.30591947,
],
dtype=np.float32,
).reshape(data_shape)
filters_value = np.array(
[
-0.06230065,
0.37932432,
-0.25388849,
0.33878803,
0.43709868,
-0.22477469,
0.04118127,
-0.44696793,
0.06373066,
],
dtype=np.float32,
).reshape(filters_shape)
computation = runtime.computation(model, data_node, filters_node)
result = computation(data_value, filters_value)
expected = np.array(
[
0.07368518,
-0.08925839,
-0.06627201,
0.06301362,
0.03732984,
-0.01919658,
-0.00628807,
-0.02817563,
-0.01472169,
0.04392925,
-0.00689478,
-0.01549204,
0.07957941,
-0.11459791,
-0.09505399,
0.07681622,
0.03604182,
-0.01853423,
-0.0270785,
-0.00680824,
-0.06650258,
0.08004665,
0.07918708,
0.0724144,
0.06256775,
-0.17838378,
-0.18863615,
0.20064656,
0.133717,
-0.06876295,
-0.06398046,
-0.00864975,
0.19289537,
-0.01490572,
-0.13673618,
0.01949645,
],
dtype=np.float32,
).reshape(1, 1, 6, 6)
assert np.allclose(result, expected)
def test_group_convolution_backprop_data_output_shape(): def test_group_convolution_backprop_data_output_shape():
runtime = get_runtime()
data_shape = [1, 1, 1, 10] data_shape = [1, 1, 1, 10]
filters_shape = [1, 1, 1, 1, 5] filters_shape = [1, 1, 1, 1, 5]
strides = [1, 1] strides = [1, 1]
@ -749,18 +356,7 @@ def test_group_convolution_backprop_data_output_shape():
model = ng.group_convolution_backprop_data( model = ng.group_convolution_backprop_data(
data_node, filters_node, strides, output_shape_node, auto_pad="same_upper" data_node, filters_node, strides, output_shape_node, auto_pad="same_upper"
) )
assert model.get_type_name() == "GroupConvolutionBackpropData"
data_value = np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0], dtype=np.float32).reshape( assert model.get_output_size() == 1
data_shape assert model.get_output_element_type(0) == Type.f32
) assert list(model.get_output_shape(0)) == [1, 1, 1, 14]
filters_value = np.array([1.0, 2.0, 3.0, 2.0, 1.0], dtype=np.float32).reshape(filters_shape)
computation = runtime.computation(model, data_node, filters_node)
result = computation(data_value, filters_value)
expected = np.array(
[0.0, 1.0, 4.0, 10.0, 18.0, 27.0, 36.0, 45.0, 54.0, 63.0, 62.0, 50.0, 26.0, 9.0], dtype=np.float32,
).reshape(1, 1, 1, 14)
assert np.allclose(result, expected)

35
src/bindings/python/tests_compatibility/test_ngraph/test_ops_matmul.py
View File

@ -5,36 +5,33 @@ import numpy as np
import pytest import pytest
import ngraph as ng import ngraph as ng
from tests_compatibility.test_ngraph.util import run_op_node from ngraph.impl import Type
@pytest.mark.parametrize( @pytest.mark.parametrize(
"shape_a, shape_b, transpose_a, transpose_b", ("shape_a", "shape_b", "transpose_a", "transpose_b", "expected_shape"),
[ [
# matrix, vector # matrix, vector
([2, 4], [4], False, False), ([2, 4], [4], False, False, [2]),
([4], [4, 2], False, False), ([4], [4, 2], False, False, [2]),
# matrix, matrix # matrix, matrix
([2, 4], [4, 2], False, False), ([2, 4], [4, 2], False, False, [2, 2]),
# tensor, vector # tensor, vector
([2, 4, 5], [5], False, False), ([2, 4, 5], [5], False, False, [2, 4]),
# # tensor, matrix # # tensor, matrix
([2, 4, 5], [5, 4], False, False), ([2, 4, 5], [5, 4], False, False, [2, 4, 4]),
# # tensor, tensor # # tensor, tensor
([2, 2, 4], [2, 4, 2], False, False), ([2, 2, 4], [2, 4, 2], False, False, [2, 2, 2]),
], ],
) )
def test_matmul(shape_a, shape_b, transpose_a, transpose_b): def test_matmul(shape_a, shape_b, transpose_a, transpose_b, expected_shape):
np.random.seed(133391) np.random.seed(133391)
left_input = -100.0 + np.random.rand(*shape_a).astype(np.float32) * 200.0 left_input = np.random.rand(*shape_a).astype(np.float32)
right_input = -100.0 + np.random.rand(*shape_b).astype(np.float32) * 200.0 right_input = np.random.rand(*shape_b).astype(np.float32)
result = run_op_node([left_input, right_input], ng.matmul, transpose_a, transpose_b) node = ng.matmul(left_input, right_input, transpose_a, transpose_b)
if transpose_a: assert node.get_output_size() == 1
left_input = np.transpose(left_input) assert node.get_type_name() == "MatMul"
if transpose_b: assert list(node.get_output_shape(0)) == expected_shape
right_input = np.transpose(right_input) assert node.get_output_element_type(0) == Type.f32
expected = np.matmul(left_input, right_input)
assert np.allclose(result, expected)

29
src/bindings/python/tests_compatibility/test_ngraph/test_ops_multioutput.py
View File

@ -4,33 +4,34 @@
import numpy as np import numpy as np
import ngraph as ng import ngraph as ng
from tests_compatibility.runtime import get_runtime from ngraph.impl import Type
def test_split(): def test_split():
runtime = get_runtime()
input_tensor = ng.constant(np.array([0, 1, 2, 3, 4, 5], dtype=np.int32)) input_tensor = ng.constant(np.array([0, 1, 2, 3, 4, 5], dtype=np.int32))
axis = ng.constant(0, dtype=np.int64) axis = ng.constant(0, dtype=np.int64)
splits = 3 splits = 3
split_node = ng.split(input_tensor, axis, splits) split_node = ng.split(input_tensor, axis, splits)
computation = runtime.computation(split_node) assert split_node.get_type_name() == "Split"
split_results = computation() assert split_node.get_output_size() == 3
expected_results = np.array([[0, 1], [2, 3], [4, 5]], dtype=np.int32) assert list(split_node.get_output_shape(0)) == [2]
assert np.allclose(split_results, expected_results) assert list(split_node.get_output_shape(1)) == [2]
assert list(split_node.get_output_shape(2)) == [2]
assert split_node.get_output_element_type(0) == Type.i32
assert split_node.get_output_element_type(1) == Type.i32
assert split_node.get_output_element_type(2) == Type.i32
def test_variadic_split(): def test_variadic_split():
runtime = get_runtime()
input_tensor = ng.constant(np.array([[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11]], dtype=np.int32)) input_tensor = ng.constant(np.array([[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11]], dtype=np.int32))
axis = ng.constant(1, dtype=np.int64) axis = ng.constant(1, dtype=np.int64)
splits = ng.constant(np.array([2, 4], dtype=np.int64)) splits = ng.constant(np.array([2, 4], dtype=np.int64))
v_split_node = ng.variadic_split(input_tensor, axis, splits) v_split_node = ng.variadic_split(input_tensor, axis, splits)
computation = runtime.computation(v_split_node) assert v_split_node.get_type_name() == "VariadicSplit"
results = computation() assert v_split_node.get_output_size() == 2
split0 = np.array([[0, 1], [6, 7]], dtype=np.int32) assert list(v_split_node.get_output_shape(0)) == [2, 2]
split1 = np.array([[2, 3, 4, 5], [8, 9, 10, 11]], dtype=np.int32) assert list(v_split_node.get_output_shape(1)) == [2, 4]
assert v_split_node.get_output_element_type(0) == Type.i32
assert np.allclose(results[0], split0) assert v_split_node.get_output_element_type(1) == Type.i32
assert np.allclose(results[1], split1)

103
src/bindings/python/tests_compatibility/test_ngraph/test_ops_reshape.py
View File

@ -1,36 +1,37 @@
# Copyright (C) 2018-2022 Intel Corporation # Copyright (C) 2018-2022 Intel Corporation
# SPDX-License-Identifier: Apache-2.0 # SPDX-License-Identifier: Apache-2.0
import ngraph as ng
import numpy as np import numpy as np
import pytest import pytest
from tests_compatibility.runtime import get_runtime import ngraph as ng
from tests_compatibility.test_ngraph.util import run_op_node, run_op_numeric_data from ngraph.impl import Type
from ngraph.utils.types import get_element_type
def test_concat(): def test_concat():
a = np.array([[1, 2], [3, 4]]) a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]]) b = np.array([[5, 6]])
axis = 0 axis = 0
expected = np.concatenate((a, b), axis=0)
runtime = get_runtime()
parameter_a = ng.parameter(list(a.shape), name="A", dtype=np.float32) parameter_a = ng.parameter(list(a.shape), name="A", dtype=np.float32)
parameter_b = ng.parameter(list(b.shape), name="B", dtype=np.float32) parameter_b = ng.parameter(list(b.shape), name="B", dtype=np.float32)
node = ng.concat([parameter_a, parameter_b], axis) node = ng.concat([parameter_a, parameter_b], axis)
computation = runtime.computation(node, parameter_a, parameter_b) assert node.get_type_name() == "Concat"
result = computation(a, b) assert node.get_output_size() == 1
assert np.allclose(result, expected) assert list(node.get_output_shape(0)) == [3, 2]
assert node.get_output_element_type(0) == Type.f32
@pytest.mark.parametrize( @pytest.mark.parametrize(
"val_type, value", [(bool, False), (bool, np.empty((2, 2), dtype=bool))] ("val_type", "value", "output_shape"), [(bool, False, []), (bool, np.empty((2, 2), dtype=bool), [2, 2])]
) )
def test_constant_from_bool(val_type, value): def test_constant_from_bool(val_type, value, output_shape):
expected = np.array(value, dtype=val_type) node = ng.constant(value, val_type)
result = run_op_numeric_data(value, ng.constant, val_type) assert node.get_type_name() == "Constant"
assert np.allclose(result, expected) assert node.get_output_size() == 1
assert node.get_output_element_type(0) == Type.boolean
assert list(node.get_output_shape(0)) == output_shape
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -49,9 +50,11 @@ def test_constant_from_bool(val_type, value):
], ],
) )
def test_constant_from_scalar(val_type, value): def test_constant_from_scalar(val_type, value):
expected = np.array(value, dtype=val_type) node = ng.constant(value, val_type)
result = run_op_numeric_data(value, ng.constant, val_type) assert node.get_type_name() == "Constant"
assert np.allclose(result, expected) assert node.get_output_size() == 1
assert node.get_output_element_type(0) == get_element_type(val_type)
assert list(node.get_output_shape(0)) == []
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -64,8 +67,11 @@ def test_constant_from_scalar(val_type, value):
def test_constant_from_float_array(val_type): def test_constant_from_float_array(val_type):
np.random.seed(133391) np.random.seed(133391)
input_data = np.array(-1 + np.random.rand(2, 3, 4) * 2, dtype=val_type) input_data = np.array(-1 + np.random.rand(2, 3, 4) * 2, dtype=val_type)
result = run_op_numeric_data(input_data, ng.constant, val_type) node = ng.constant(input_data, val_type)
assert np.allclose(result, input_data) assert node.get_type_name() == "Constant"
assert node.get_output_size() == 1
assert node.get_output_element_type(0) == get_element_type(val_type)
assert list(node.get_output_shape(0)) == [2, 3, 4]
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -86,8 +92,11 @@ def test_constant_from_integer_array(val_type, range_start, range_end):
input_data = np.array( input_data = np.array(
np.random.randint(range_start, range_end, size=(2, 2)), dtype=val_type np.random.randint(range_start, range_end, size=(2, 2)), dtype=val_type
) )
result = run_op_numeric_data(input_data, ng.constant, val_type) node = ng.constant(input_data, val_type)
assert np.allclose(result, input_data) assert node.get_type_name() == "Constant"
assert node.get_output_size() == 1
assert node.get_output_element_type(0) == get_element_type(val_type)
assert list(node.get_output_shape(0)) == [2, 2]
def test_broadcast_numpy(): def test_broadcast_numpy():
@ -126,27 +135,25 @@ def test_transpose():
) )
input_order = np.array([0, 2, 3, 1], dtype=np.int32) input_order = np.array([0, 2, 3, 1], dtype=np.int32)
result = run_op_node([input_tensor], ng.transpose, input_order) node = ng.transpose(input_tensor, input_order)
assert node.get_type_name() == "Transpose"
expected = np.transpose(input_tensor, input_order) assert node.get_output_size() == 1
assert node.get_output_element_type(0) == Type.i32
assert np.allclose(result, expected) assert list(node.get_output_shape(0)) == [3, 224, 224, 3]
def test_tile(): def test_tile():
input_tensor = np.arange(6, dtype=np.int32).reshape((2, 1, 3)) input_tensor = np.arange(6, dtype=np.int32).reshape((2, 1, 3))
repeats = np.array([2, 1], dtype=np.int32) repeats = np.array([2, 1], dtype=np.int32)
result = run_op_node([input_tensor], ng.tile, repeats) node = ng.tile(input_tensor, repeats)
expected = np.array([0, 1, 2, 0, 1, 2, 3, 4, 5, 3, 4, 5]).reshape((2, 2, 3)) assert node.get_type_name() == "Tile"
assert node.get_output_size() == 1
assert np.allclose(result, expected) assert node.get_output_element_type(0) == Type.i32
assert list(node.get_output_shape(0)) == [2, 2, 3]
@pytest.mark.xfail(
reason="RuntimeError: Check 'shape_size(get_input_shape(0)) == shape_size(output_shape)'"
)
def test_strided_slice(): def test_strided_slice():
input_tensor = np.arange(2 * 3 * 4, dtype=np.float32).reshape((2, 3, 4)) input_tensor = np.arange(2 * 3 * 4, dtype=np.float32).reshape((2, 3, 4))
begin = np.array([1, 0], dtype=np.int32) begin = np.array([1, 0], dtype=np.int32)
@ -158,9 +165,8 @@ def test_strided_slice():
shrink_axis_mask = np.array([1, 0, 0], dtype=np.int32) shrink_axis_mask = np.array([1, 0, 0], dtype=np.int32)
ellipsis_mask = np.array([0, 0, 0], dtype=np.int32) ellipsis_mask = np.array([0, 0, 0], dtype=np.int32)
result = run_op_node( node = ng.strided_slice(
[input_tensor], input_tensor,
ng.strided_slice,
begin, begin,
end, end,
strides, strides,
@ -171,11 +177,10 @@ def test_strided_slice():
ellipsis_mask, ellipsis_mask,
) )
expected = np.array( assert node.get_type_name() == "StridedSlice"
[12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23], dtype=np.float32 assert node.get_output_size() == 1
).reshape((1, 3, 4)) assert node.get_output_element_type(0) == Type.f32
assert list(node.get_output_shape(0)) == [1, 3, 4]
assert np.allclose(result, expected)
def test_reshape_v1(): def test_reshape_v1():
@ -183,16 +188,18 @@ def test_reshape_v1():
shape = np.array([0, -1, 4], dtype=np.int32) shape = np.array([0, -1, 4], dtype=np.int32)
special_zero = True special_zero = True
expected_shape = np.array([2, 150, 4]) node = ng.reshape(A, shape, special_zero)
expected = np.reshape(A, expected_shape) assert node.get_type_name() == "Reshape"
result = run_op_node([A], ng.reshape, shape, special_zero) assert node.get_output_size() == 1
assert node.get_output_element_type(0) == Type.f32
assert np.allclose(result, expected) assert list(node.get_output_shape(0)) == [2, 150, 4]
def test_shape_of(): def test_shape_of():
input_tensor = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.float32) input_tensor = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.float32)
result = run_op_node([input_tensor], ng.shape_of) node = ng.shape_of(input_tensor)
assert node.get_type_name() == "ShapeOf"
assert np.allclose(result, [3, 3]) assert node.get_output_size() == 1
assert node.get_output_element_type(0) == Type.i64
assert list(node.get_output_shape(0)) == [2]

268
src/bindings/python/tests_compatibility/test_ngraph/test_ops_unary.py
View File

@ -6,129 +6,118 @@ import pytest
import ngraph as ng import ngraph as ng
from ngraph.impl import Shape, Type from ngraph.impl import Shape, Type
from tests_compatibility.runtime import get_runtime
from tests_compatibility.test_ngraph.util import run_op_node
R_TOLERANCE = 1e-6 # global relative tolerance R_TOLERANCE = 1e-6 # global relative tolerance
@pytest.mark.parametrize( @pytest.mark.parametrize(
"graph_api_fn, numpy_fn, range_start, range_end", ("graph_api_fn", "type_name"),
[ [
(ng.absolute, np.abs, -1, 1), (ng.absolute, "Abs"),
(ng.abs, np.abs, -1, 1), (ng.abs, "Abs"),
(ng.acos, np.arccos, -1, 1), (ng.acos, "Acos"),
(ng.acosh, np.arccosh, 1, 2), (ng.acosh, "Acosh"),
(ng.asin, np.arcsin, -1, 1), (ng.asin, "Asin"),
(ng.asinh, np.arcsinh, -1, 1), (ng.asinh, "Asinh"),
(ng.atan, np.arctan, -100.0, 100.0), (ng.atan, "Atan"),
(ng.atanh, np.arctanh, 0.0, 1.0), (ng.atanh, "Atanh"),
(ng.ceiling, np.ceil, -100.0, 100.0), (ng.ceiling, "Ceiling"),
(ng.ceil, np.ceil, -100.0, 100.0), (ng.ceil, "Ceiling"),
(ng.cos, np.cos, -100.0, 100.0), (ng.cos, "Cos"),
(ng.cosh, np.cosh, -100.0, 100.0), (ng.cosh, "Cosh"),
(ng.exp, np.exp, -100.0, 100.0), (ng.exp, "Exp"),
(ng.floor, np.floor, -100.0, 100.0), (ng.floor, "Floor"),
(ng.log, np.log, 0, 100.0), (ng.log, "Log"),
(ng.relu, lambda x: np.maximum(0, x), -100.0, 100.0), (ng.relu, "Relu"),
(ng.sign, np.sign, -100.0, 100.0), (ng.sign, "Sign"),
(ng.sin, np.sin, -100.0, 100.0), (ng.sin, "Sin"),
(ng.sinh, np.sinh, -100.0, 100.0), (ng.sinh, "Sinh"),
(ng.sqrt, np.sqrt, 0.0, 100.0), (ng.sqrt, "Sqrt"),
(ng.tan, np.tan, -1.0, 1.0), (ng.tan, "Tan"),
(ng.tanh, np.tanh, -100.0, 100.0), (ng.tanh, "Tanh"),
], ],
) )
def test_unary_op_array(graph_api_fn, numpy_fn, range_start, range_end): def test_unary_op_array(graph_api_fn, type_name):
np.random.seed(133391) np.random.seed(133391)
input_data = (range_start + np.random.rand(2, 3, 4) * (range_end - range_start)).astype(np.float32) input_data = np.random.rand(2, 3, 4).astype(np.float32)
expected = numpy_fn(input_data) node = graph_api_fn(input_data)
assert node.get_output_size() == 1
result = run_op_node([input_data], graph_api_fn) assert node.get_type_name() == type_name
assert np.allclose(result, expected, rtol=0.001) assert node.get_output_element_type(0) == Type.f32
assert list(node.get_output_shape(0)) == [2, 3, 4]
@pytest.mark.parametrize( @pytest.mark.parametrize(
"graph_api_fn, numpy_fn, input_data", ("graph_api_fn", "input_data"),
[ [
pytest.param(ng.absolute, np.abs, np.float32(-3)), pytest.param(ng.absolute, np.float32(-3)),
pytest.param(ng.abs, np.abs, np.float32(-3)), pytest.param(ng.abs, np.float32(-3)),
pytest.param(ng.acos, np.arccos, np.float32(-0.5)), pytest.param(ng.acos, np.float32(-0.5)),
pytest.param(ng.asin, np.arcsin, np.float32(-0.5)), pytest.param(ng.asin, np.float32(-0.5)),
pytest.param(ng.atan, np.arctan, np.float32(-0.5)), pytest.param(ng.atan, np.float32(-0.5)),
pytest.param(ng.ceiling, np.ceil, np.float32(1.5)), pytest.param(ng.ceiling, np.float32(1.5)),
pytest.param(ng.ceil, np.ceil, np.float32(1.5)), pytest.param(ng.ceil, np.float32(1.5)),
pytest.param(ng.cos, np.cos, np.float32(np.pi / 4.0)), pytest.param(ng.cos, np.float32(np.pi / 4.0)),
pytest.param(ng.cosh, np.cosh, np.float32(np.pi / 4.0)), pytest.param(ng.cosh, np.float32(np.pi / 4.0)),
pytest.param(ng.exp, np.exp, np.float32(1.5)), pytest.param(ng.exp, np.float32(1.5)),
pytest.param(ng.floor, np.floor, np.float32(1.5)), pytest.param(ng.floor, np.float32(1.5)),
pytest.param(ng.log, np.log, np.float32(1.5)), pytest.param(ng.log, np.float32(1.5)),
pytest.param(ng.relu, lambda x: np.maximum(0, x), np.float32(-0.125)), pytest.param(ng.relu, np.float32(-0.125)),
pytest.param(ng.sign, np.sign, np.float32(0.0)), pytest.param(ng.sign, np.float32(0.0)),
pytest.param(ng.sin, np.sin, np.float32(np.pi / 4.0)), pytest.param(ng.sin, np.float32(np.pi / 4.0)),
pytest.param(ng.sinh, np.sinh, np.float32(0.0)), pytest.param(ng.sinh, np.float32(0.0)),
pytest.param(ng.sqrt, np.sqrt, np.float32(3.5)), pytest.param(ng.sqrt, np.float32(3.5)),
pytest.param(ng.tan, np.tan, np.float32(np.pi / 4.0)), pytest.param(ng.tan, np.float32(np.pi / 4.0)),
pytest.param(ng.tanh, np.tanh, np.float32(0.1234)), pytest.param(ng.tanh, np.float32(0.1234)),
], ],
) )
def test_unary_op_scalar(graph_api_fn, numpy_fn, input_data): def test_unary_op_scalar(graph_api_fn, input_data):
expected = numpy_fn(input_data) node = graph_api_fn(input_data)
result = run_op_node([input_data], graph_api_fn) assert node.get_output_size() == 1
assert np.allclose(result, expected) assert node.get_output_element_type(0) == Type.f32
assert list(node.get_output_shape(0)) == []
@pytest.mark.parametrize( @pytest.mark.parametrize(
"input_data", [(np.array([True, False, True, False])), (np.array([True])), (np.array([False]))] "input_data", [(np.array([True, False, True, False])), (np.array([True])), (np.array([False]))]
) )
def test_logical_not(input_data): def test_logical_not(input_data):
expected = np.logical_not(input_data) node = ng.logical_not(input_data)
assert node.get_output_size() == 1
result = run_op_node([input_data], ng.logical_not) assert node.get_type_name() == "LogicalNot"
assert np.allclose(result, expected) assert node.get_output_element_type(0) == Type.boolean
assert list(node.get_output_shape(0)) == list(input_data.shape)
def test_sigmoid(): def test_sigmoid():
input_data = np.array([-3.14, -1.0, 0.0, 2.71001, 1000.0], dtype=np.float32) input_data = np.array([-3.14, -1.0, 0.0, 2.71001, 1000.0], dtype=np.float32)
result = run_op_node([input_data], ng.sigmoid) node = ng.sigmoid(input_data)
def sigmoid(x): assert node.get_output_size() == 1
return 1.0 / (1.0 + np.exp(-x)) assert node.get_type_name() == "Sigmoid"
assert node.get_output_element_type(0) == Type.f32
expected = np.array(list(map(sigmoid, input_data))) assert list(node.get_output_shape(0)) == [5]
assert np.allclose(result, expected)
def test_softmax_positive_axis(): def test_softmax():
axis = 1 axis = 1
input_tensor = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32) input_tensor = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32)
result = run_op_node([input_tensor], ng.softmax, axis) node = ng.softmax(input_tensor, axis)
assert node.get_output_size() == 1
expected = [[0.09003056, 0.24472842, 0.6652409], [0.09003056, 0.24472842, 0.6652409]] assert node.get_type_name() == "Softmax"
assert node.get_output_element_type(0) == Type.f32
assert np.allclose(result, expected) assert list(node.get_output_shape(0)) == [2, 3]
def test_softmax_negative_axis():
axis = -1
input_tensor = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32)
result = run_op_node([input_tensor], ng.softmax, axis)
expected = [[0.09003056, 0.24472842, 0.6652409], [0.09003056, 0.24472842, 0.6652409]]
assert np.allclose(result, expected)
def test_erf(): def test_erf():
input_tensor = np.array([-1.0, 0.0, 1.0, 2.5, 3.14, 4.0], dtype=np.float32) input_tensor = np.array([-1.0, 0.0, 1.0, 2.5, 3.14, 4.0], dtype=np.float32)
expected = [-0.842701, 0.0, 0.842701, 0.999593, 0.999991, 1.0] node = ng.erf(input_tensor)
assert node.get_output_size() == 1
result = run_op_node([input_tensor], ng.erf) assert node.get_type_name() == "Erf"
assert np.allclose(result, expected) assert node.get_output_element_type(0) == Type.f32
assert list(node.get_output_shape(0)) == [6]
def test_hswish(): def test_hswish():
@ -152,29 +141,6 @@ def test_round_even():
assert list(node.get_output_shape(0)) == [3, 10] assert list(node.get_output_shape(0)) == [3, 10]
assert node.get_output_element_type(0) == Type.f32 assert node.get_output_element_type(0) == Type.f32
input_tensor = np.array([-2.5, -1.5, -0.5, 0.5, 0.9, 1.5, 2.3, 2.5, 3.5], dtype=np.float32)
expected = [-2.0, -2.0, 0.0, 0.0, 1.0, 2.0, 2.0, 2.0, 4.0]
result = run_op_node([input_tensor], ng.round, "HALF_TO_EVEN")
assert np.allclose(result, expected)
def test_round_away():
float_dtype = np.float32
data = ng.parameter(Shape([3, 10]), dtype=float_dtype, name="data")
node = ng.round(data, "HALF_AWAY_FROM_ZERO")
assert node.get_type_name() == "Round"
assert node.get_output_size() == 1
assert list(node.get_output_shape(0)) == [3, 10]
assert node.get_output_element_type(0) == Type.f32
input_tensor = np.array([-2.5, -1.5, -0.5, 0.5, 0.9, 1.5, 2.3, 2.5, 3.5], dtype=np.float32)
expected = [-3.0, -2.0, -1.0, 1.0, 1.0, 2.0, 2.0, 3.0, 4.0]
result = run_op_node([input_tensor], ng.round, "HALF_AWAY_FROM_ZERO")
assert np.allclose(result, expected)
def test_hsigmoid(): def test_hsigmoid():
float_dtype = np.float32 float_dtype = np.float32
@ -188,92 +154,42 @@ def test_hsigmoid():
def test_gelu_operator_with_parameters(): def test_gelu_operator_with_parameters():
runtime = get_runtime()
data_value = np.array([[-5, 1], [-2, 3]], dtype=np.float32)
data_shape = [2, 2] data_shape = [2, 2]
parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32) parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32)
model = ng.gelu(parameter_data, "erf") model = ng.gelu(parameter_data, "erf")
computation = runtime.computation(model, parameter_data) assert model.get_output_size() == 1
assert model.get_type_name() == "Gelu"
result = computation(data_value) assert model.get_output_element_type(0) == Type.f32
expected = np.array([[-1.6391277e-06, 8.4134471e-01], [-4.5500278e-02, 2.9959502]], dtype=np.float32) assert list(model.get_output_shape(0)) == [2, 2]
assert np.allclose(result, expected, 1e-6, 1e-6)
def test_gelu_operator_with_array(): def test_gelu_operator_with_array():
runtime = get_runtime()
data_value = np.array([[-5, 1], [-2, 3]], dtype=np.float32) data_value = np.array([[-5, 1], [-2, 3]], dtype=np.float32)
model = ng.gelu(data_value, "erf") model = ng.gelu(data_value, "erf")
computation = runtime.computation(model) assert model.get_output_size() == 1
assert model.get_type_name() == "Gelu"
result = computation() assert model.get_output_element_type(0) == Type.f32
expected = np.array([[-1.6391277e-06, 8.4134471e-01], [-4.5500278e-02, 2.9959502]], dtype=np.float32) assert list(model.get_output_shape(0)) == [2, 2]
assert np.allclose(result, expected, 1e-6, 1e-6)
def test_gelu_tanh_operator_with_parameters(): def test_gelu_tanh_operator_with_parameters():
runtime = get_runtime()
data_value = np.array([[-5, 1], [-2, 3]], dtype=np.float32)
data_shape = [2, 2] data_shape = [2, 2]
parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32) parameter_data = ng.parameter(data_shape, name="Data", dtype=np.float32)
model = ng.gelu(parameter_data, "tanh") model = ng.gelu(parameter_data, "tanh")
computation = runtime.computation(model, parameter_data) assert model.get_output_size() == 1
assert model.get_type_name() == "Gelu"
result = computation(data_value) assert model.get_output_element_type(0) == Type.f32
expected = np.array([[0.0, 0.841192], [-0.04540223, 2.9963627]], dtype=np.float32) assert list(model.get_output_shape(0)) == [2, 2]
assert np.allclose(result, expected, 1e-6, 1e-6)
def test_gelu_tanh_operator_with_array(): def test_gelu_tanh_operator_with_array():
runtime = get_runtime()
data_value = np.array([[-5, 1], [-2, 3]], dtype=np.float32) data_value = np.array([[-5, 1], [-2, 3]], dtype=np.float32)
model = ng.gelu(data_value, "tanh") model = ng.gelu(data_value, "tanh")
computation = runtime.computation(model) assert model.get_output_size() == 1
assert model.get_type_name() == "Gelu"
result = computation() assert model.get_output_element_type(0) == Type.f32
expected = np.array([[0.0, 0.841192], [-0.04540223, 2.9963627]], dtype=np.float32) assert list(model.get_output_shape(0)) == [2, 2]
assert np.allclose(result, expected, 1e-6, 1e-6)
type_tolerance = [
(np.float64, 1e-6),
(np.float32, 1e-6),
(np.float16, 1e-3),
]
@pytest.mark.parametrize("type_tolerance", type_tolerance)
def test_softsign_with_parameters(type_tolerance):
dtype, atol = type_tolerance
data = np.random.uniform(-1.0, 1.0, (32, 5)).astype(dtype)
expected = np.divide(data, np.abs(data) + 1)
runtime = get_runtime()
param = ng.parameter(data.shape, dtype, name="Data")
result = runtime.computation(ng.softsign(param, "SoftSign"), param)(data)
assert np.allclose(result, expected, R_TOLERANCE, atol)
@pytest.mark.parametrize("type_tolerance", type_tolerance)
def test_softsign_with_array(type_tolerance):
dtype, atol = type_tolerance
data = np.random.uniform(-1.0, 1.0, (32, 5)).astype(dtype)
expected = np.divide(data, np.abs(data) + 1)
runtime = get_runtime()
result = runtime.computation(ng.softsign(data, "SoftSign"))()
assert np.allclose(result, expected, R_TOLERANCE, atol)

266
src/bindings/python/tests_compatibility/test_ngraph/test_pooling.py
View File

@ -5,7 +5,7 @@ import numpy as np
import pytest import pytest
import ngraph as ng import ngraph as ng
from tests_compatibility.runtime import get_runtime from ngraph.impl import Type
@pytest.fixture @pytest.fixture
@ -14,7 +14,6 @@ def _ndarray_1x1x4x4():
def test_avg_pool_2d(_ndarray_1x1x4x4): def test_avg_pool_2d(_ndarray_1x1x4x4):
runtime = get_runtime()
input_data = _ndarray_1x1x4x4 input_data = _ndarray_1x1x4x4
param = ng.parameter(input_data.shape, name="A", dtype=np.float32) param = ng.parameter(input_data.shape, name="A", dtype=np.float32)
@ -24,41 +23,15 @@ def test_avg_pool_2d(_ndarray_1x1x4x4):
pads_end = [0] * spatial_dim_count pads_end = [0] * spatial_dim_count
strides = [2, 2] strides = [2, 2]
exclude_pad = True exclude_pad = True
expected = [[[[13.5, 15.5], [21.5, 23.5]]]]
avg_pool_node = ng.avg_pool(param, strides, pads_begin, pads_end, kernel_shape, exclude_pad) avg_pool_node = ng.avg_pool(param, strides, pads_begin, pads_end, kernel_shape, exclude_pad)
computation = runtime.computation(avg_pool_node, param) assert avg_pool_node.get_type_name() == "AvgPool"
result = computation(input_data) assert avg_pool_node.get_output_size() == 1
assert np.allclose(result, expected) assert list(avg_pool_node.get_output_shape(0)) == [1, 1, 2, 2]
assert avg_pool_node.get_output_element_type(0) == Type.f32
expected = [[[[13.5, 14.5, 15.5], [17.5, 18.5, 19.5], [21.5, 22.5, 23.5]]]]
strides = [1, 1]
avg_pool_node = ng.avg_pool(param, strides, pads_begin, pads_end, kernel_shape, exclude_pad)
computation = runtime.computation(avg_pool_node, param)
result = computation(input_data)
assert np.allclose(result, expected)
pads_begin = [1, 1]
pads_end = [1, 1]
strides = [2, 2]
exclude_pad = True
expected = [[[[11.0, 12.5, 14.0], [17.0, 18.5, 20.0], [23.0, 24.5, 26.0]]]]
avg_pool_node = ng.avg_pool(param, strides, pads_begin, pads_end, kernel_shape, exclude_pad)
computation = runtime.computation(avg_pool_node, param)
result = computation(input_data)
assert np.allclose(result, expected)
exclude_pad = False
expected = [[[[2.75, 6.25, 3.5], [8.5, 18.5, 10.0], [5.75, 12.25, 6.5]]]]
avg_pool_node = ng.avg_pool(param, strides, pads_begin, pads_end, kernel_shape, exclude_pad)
computation = runtime.computation(avg_pool_node, param)
result = computation(input_data)
assert np.allclose(result, expected)
def test_avg_pooling_3d(_ndarray_1x1x4x4): def test_avg_pooling_3d(_ndarray_1x1x4x4):
rt = get_runtime()
data = _ndarray_1x1x4x4 data = _ndarray_1x1x4x4
data = np.broadcast_to(data, (1, 1, 4, 4, 4)) data = np.broadcast_to(data, (1, 1, 4, 4, 4))
param = ng.parameter(list(data.shape)) param = ng.parameter(list(data.shape))
@ -70,19 +43,13 @@ def test_avg_pooling_3d(_ndarray_1x1x4x4):
exclude_pad = True exclude_pad = True
avgpool = ng.avg_pool(param, strides, pads_begin, pads_end, kernel_shape, exclude_pad) avgpool = ng.avg_pool(param, strides, pads_begin, pads_end, kernel_shape, exclude_pad)
comp = rt.computation(avgpool, param) assert avgpool.get_type_name() == "AvgPool"
result = comp(data) assert avgpool.get_output_size() == 1
result_ref = [[[[[13.5, 15.5], [21.5, 23.5]], [[13.5, 15.5], [21.5, 23.5]]]]] assert list(avgpool.get_output_shape(0)) == [1, 1, 2, 2, 2]
assert np.allclose(result, result_ref) assert avgpool.get_output_element_type(0) == Type.f32
def test_max_pool_basic(): def test_max_pool_basic():
rt = get_runtime()
# array([[[[ 0.5, 1.5, 2.5, 3.5],
# [ 4.5, 5.5, 6.5, 7.5],
# [ 8.5, 9.5, 10.5, 11.5],
# [12.5, 13.5, 14.5, 15.5]]]], dtype=float32)
data = np.arange(0.5, 16, dtype=np.float32).reshape((1, 1, 4, 4)) data = np.arange(0.5, 16, dtype=np.float32).reshape((1, 1, 4, 4))
strides = [1, 1] strides = [1, 1]
dilations = [1, 1] dilations = [1, 1]
@ -105,24 +72,15 @@ def test_max_pool_basic():
auto_pad, auto_pad,
index_et, index_et,
) )
comp = rt.computation(maxpool_node, data_node) assert maxpool_node.get_type_name() == "MaxPool"
result = comp(data) assert maxpool_node.get_output_size() == 2
assert list(maxpool_node.get_output_shape(0)) == [1, 1, 3, 3]
expected = np.array( assert list(maxpool_node.get_output_shape(1)) == [1, 1, 3, 3]
[[[[5.5, 6.5, 7.5], [9.5, 10.5, 11.5], [13.5, 14.5, 15.5]]]], dtype=np.float32 assert maxpool_node.get_output_element_type(0) == Type.f32
) assert maxpool_node.get_output_element_type(1) == Type.i32
expected_idx = np.array([[[[5, 6, 7], [9, 10, 11], [13, 14, 15]]]], dtype=np.int32)
assert np.allclose(result[0], expected)
assert np.allclose(result[1], expected_idx)
def test_max_pool_strides(): def test_max_pool_strides():
rt = get_runtime()
# array([[[[ 0.5, 1.5, 2.5, 3.5],
# [ 4.5, 5.5, 6.5, 7.5],
# [ 8.5, 9.5, 10.5, 11.5],
# [12.5, 13.5, 14.5, 15.5]]]], dtype=float32)
data = np.arange(0.5, 16, dtype=np.float32).reshape((1, 1, 4, 4)) data = np.arange(0.5, 16, dtype=np.float32).reshape((1, 1, 4, 4))
strides = [2, 1] strides = [2, 1]
dilations = [1, 1] dilations = [1, 1]
@ -145,22 +103,15 @@ def test_max_pool_strides():
auto_pad, auto_pad,
index_et, index_et,
) )
comp = rt.computation(maxpool_node, data_node) assert maxpool_node.get_type_name() == "MaxPool"
result = comp(data) assert maxpool_node.get_output_size() == 2
assert list(maxpool_node.get_output_shape(0)) == [1, 1, 2, 3]
expected = np.array([[[[5.5, 6.5, 7.5], [13.5, 14.5, 15.5]]]], dtype=np.float32) assert list(maxpool_node.get_output_shape(1)) == [1, 1, 2, 3]
expected_idx = np.array([[[[5, 6, 7], [13, 14, 15]]]], dtype=np.int32) assert maxpool_node.get_output_element_type(0) == Type.f32
assert np.allclose(result[0], expected) assert maxpool_node.get_output_element_type(1) == Type.i32
assert np.allclose(result[1], expected_idx)
def test_max_pool_kernel_shape1x1(): def test_max_pool_kernel_shape1x1():
rt = get_runtime()
# array([[[[ 0.5, 1.5, 2.5, 3.5],
# [ 4.5, 5.5, 6.5, 7.5],
# [ 8.5, 9.5, 10.5, 11.5],
# [12.5, 13.5, 14.5, 15.5]]]], dtype=float32)
data = np.arange(0.5, 16, dtype=np.float32).reshape((1, 1, 4, 4)) data = np.arange(0.5, 16, dtype=np.float32).reshape((1, 1, 4, 4))
strides = [1, 1] strides = [1, 1]
dilations = [1, 1] dilations = [1, 1]
@ -183,20 +134,15 @@ def test_max_pool_kernel_shape1x1():
auto_pad, auto_pad,
index_et, index_et,
) )
comp = rt.computation(maxpool_node, data_node) assert maxpool_node.get_type_name() == "MaxPool"
result = comp(data) assert maxpool_node.get_output_size() == 2
assert list(maxpool_node.get_output_shape(0)) == [1, 1, 4, 4]
assert np.allclose(result[0], data) assert list(maxpool_node.get_output_shape(1)) == [1, 1, 4, 4]
assert np.allclose(result[1], np.arange(0, 16, dtype=np.int32).reshape((1, 1, 4, 4))) assert maxpool_node.get_output_element_type(0) == Type.f32
assert maxpool_node.get_output_element_type(1) == Type.i32
def test_max_pool_kernel_shape3x3(): def test_max_pool_kernel_shape3x3():
rt = get_runtime()
# array([[[[ 0.5, 1.5, 2.5, 3.5],
# [ 4.5, 5.5, 6.5, 7.5],
# [ 8.5, 9.5, 10.5, 11.5],
# [12.5, 13.5, 14.5, 15.5]]]], dtype=float32)
data = np.arange(0.5, 16, dtype=np.float32).reshape((1, 1, 4, 4)) data = np.arange(0.5, 16, dtype=np.float32).reshape((1, 1, 4, 4))
strides = [1, 1] strides = [1, 1]
dilations = [1, 1] dilations = [1, 1]
@ -219,31 +165,20 @@ def test_max_pool_kernel_shape3x3():
auto_pad, auto_pad,
index_et, index_et,
) )
comp = rt.computation(maxpool_node, data_node) assert maxpool_node.get_type_name() == "MaxPool"
result = comp(data) assert maxpool_node.get_output_size() == 2
assert list(maxpool_node.get_output_shape(0)) == [1, 1, 2, 2]
expected = np.array([[[[10.5, 11.5], [14.5, 15.5]]]], dtype=np.float32) assert list(maxpool_node.get_output_shape(1)) == [1, 1, 2, 2]
assert np.allclose(result[0], expected) assert maxpool_node.get_output_element_type(0) == Type.f32
assert maxpool_node.get_output_element_type(1) == Type.i32
def test_max_pool_non_zero_pads(): def test_max_pool_non_zero_pads():
rt = get_runtime()
# array([[[[ 0.5, 1.5, 2.5, 3.5],
# [ 4.5, 5.5, 6.5, 7.5],
# [ 8.5, 9.5, 10.5, 11.5],
# [12.5, 13.5, 14.5, 15.5]]]], dtype=float32)
data = np.arange(0.5, 16, dtype=np.float32).reshape((1, 1, 4, 4)) data = np.arange(0.5, 16, dtype=np.float32).reshape((1, 1, 4, 4))
strides = [1, 1] strides = [1, 1]
dilations = [1, 1] dilations = [1, 1]
pads_begin = [1, 1] pads_begin = [1, 1]
pads_end = [1, 1] pads_end = [1, 1]
# 0 0 , 0 , 0 , 0, 0
# 0 [ 0.5, 1.5, 2.5, 3.5], 0,
# 0 [ 4.5, 5.5, 6.5, 7.5], 0,
# 0 [ 8.5, 9.5, 10.5, 11.5], 0,
# 0 [12.5, 13.5, 14.5, 15.5], 0
# 0 0 , 0 , 0 , 0, 0
kernel_shape = [2, 2] kernel_shape = [2, 2]
rounding_type = "floor" rounding_type = "floor"
auto_pad = None auto_pad = None
@ -261,58 +196,20 @@ def test_max_pool_non_zero_pads():
auto_pad, auto_pad,
index_et, index_et,
) )
comp = rt.computation(maxpool_node, data_node) assert maxpool_node.get_type_name() == "MaxPool"
result = comp(data) assert maxpool_node.get_output_size() == 2
assert list(maxpool_node.get_output_shape(0)) == [1, 1, 5, 5]
expected = np.array( assert list(maxpool_node.get_output_shape(1)) == [1, 1, 5, 5]
[ assert maxpool_node.get_output_element_type(0) == Type.f32
[ assert maxpool_node.get_output_element_type(1) == Type.i32
[
[0.5, 1.5, 2.5, 3.5, 3.5],
[4.5, 5.5, 6.5, 7.5, 7.5],
[8.5, 9.5, 10.5, 11.5, 11.5],
[12.5, 13.5, 14.5, 15.5, 15.5],
[12.5, 13.5, 14.5, 15.5, 15.5],
]
]
],
dtype=np.float32,
)
expected_idx = np.array(
[
[
[
[0, 1, 2, 3, 3],
[4, 5, 6, 7, 7],
[8, 9, 10, 11, 11],
[12, 13, 14, 15, 15],
[12, 13, 14, 15, 15],
]
]
],
dtype=np.int32,
)
assert np.allclose(result[0], expected)
assert np.allclose(result[1], expected_idx)
def test_max_pool_same_upper_auto_pads(): def test_max_pool_same_upper_auto_pads():
rt = get_runtime()
# array([[[[ 0.5, 1.5, 2.5, 3.5],
# [ 4.5, 5.5, 6.5, 7.5],
# [ 8.5, 9.5, 10.5, 11.5],
# [12.5, 13.5, 14.5, 15.5]]]], dtype=float32)
data = np.arange(0.5, 16, dtype=np.float32).reshape((1, 1, 4, 4)) data = np.arange(0.5, 16, dtype=np.float32).reshape((1, 1, 4, 4))
strides = [1, 1] strides = [1, 1]
dilations = [1, 1] dilations = [1, 1]
pads_begin = [0, 0] pads_begin = [0, 0]
pads_end = [0, 0] pads_end = [0, 0]
# [ 0.5, 1.5, 2.5, 3.5], 0,
# [ 4.5, 5.5, 6.5, 7.5], 0,
# [ 8.5, 9.5, 10.5, 11.5], 0,
# [12.5, 13.5, 14.5, 15.5], 0
# 0 , 0 , 0 , 0, 0
kernel_shape = [2, 2] kernel_shape = [2, 2]
auto_pad = "same_upper" auto_pad = "same_upper"
rounding_type = "floor" rounding_type = "floor"
@ -330,56 +227,20 @@ def test_max_pool_same_upper_auto_pads():
auto_pad, auto_pad,
index_et, index_et,
) )
comp = rt.computation(maxpool_node, data_node) assert maxpool_node.get_type_name() == "MaxPool"
result = comp(data) assert maxpool_node.get_output_size() == 2
assert list(maxpool_node.get_output_shape(0)) == [1, 1, 4, 4]
expected = np.array( assert list(maxpool_node.get_output_shape(1)) == [1, 1, 4, 4]
[ assert maxpool_node.get_output_element_type(0) == Type.f32
[ assert maxpool_node.get_output_element_type(1) == Type.i32
[
[5.5, 6.5, 7.5, 7.5],
[9.5, 10.5, 11.5, 11.5],
[13.5, 14.5, 15.5, 15.5],
[13.5, 14.5, 15.5, 15.5],
]
]
],
dtype=np.float32,
)
expected_idx = np.array(
[
[
[
[5, 6, 7, 7],
[9, 10, 11, 11],
[13, 14, 15, 15],
[13, 14, 15, 15],
]
]
],
dtype=np.int32,
)
assert np.allclose(result[0], expected)
assert np.allclose(result[1], expected_idx)
def test_max_pool_same_lower_auto_pads(): def test_max_pool_same_lower_auto_pads():
rt = get_runtime()
# array([[[[ 0.5, 1.5, 2.5, 3.5],
# [ 4.5, 5.5, 6.5, 7.5],
# [ 8.5, 9.5, 10.5, 11.5],
# [12.5, 13.5, 14.5, 15.5]]]], dtype=float32)
data = np.arange(0.5, 16, dtype=np.float32).reshape((1, 1, 4, 4)) data = np.arange(0.5, 16, dtype=np.float32).reshape((1, 1, 4, 4))
strides = [1, 1] strides = [1, 1]
dilations = [1, 1] dilations = [1, 1]
pads_begin = [0, 0] pads_begin = [0, 0]
pads_end = [0, 0] pads_end = [0, 0]
# 0 0 , 0 , 0 , 0,
# 0 [ 0.5, 1.5, 2.5, 3.5],
# 0 [ 4.5, 5.5, 6.5, 7.5],
# 0 [ 8.5, 9.5, 10.5, 11.5],
# 0 [12.5, 13.5, 14.5, 15.5],
kernel_shape = [2, 2] kernel_shape = [2, 2]
auto_pad = "same_lower" auto_pad = "same_lower"
rounding_type = "floor" rounding_type = "floor"
@ -397,34 +258,9 @@ def test_max_pool_same_lower_auto_pads():
auto_pad, auto_pad,
index_et, index_et,
) )
comp = rt.computation(maxpool_node, data_node) assert maxpool_node.get_type_name() == "MaxPool"
result = comp(data) assert maxpool_node.get_output_size() == 2
assert list(maxpool_node.get_output_shape(0)) == [1, 1, 4, 4]
expected = np.array( assert list(maxpool_node.get_output_shape(1)) == [1, 1, 4, 4]
[ assert maxpool_node.get_output_element_type(0) == Type.f32
[ assert maxpool_node.get_output_element_type(1) == Type.i32
[
[0.5, 1.5, 2.5, 3.5],
[4.5, 5.5, 6.5, 7.5],
[8.5, 9.5, 10.5, 11.5],
[12.5, 13.5, 14.5, 15.5],
]
]
],
dtype=np.float32,
)
expected_idx = np.array(
[
[
[
[0, 1, 2, 3],
[4, 5, 6, 7],
[8, 9, 10, 11],
[12, 13, 14, 15],
]
]
],
dtype=np.int32,
)
assert np.allclose(result[0], expected)
assert np.allclose(result[1], expected_idx)

24
src/bindings/python/tests_compatibility/test_ngraph/test_random_uniform.py
View File

@ -2,12 +2,12 @@
# SPDX-License-Identifier: Apache-2.0 # SPDX-License-Identifier: Apache-2.0
import ngraph as ng import ngraph as ng
from ngraph.impl import Type
import numpy as np import numpy as np
from tests_compatibility.runtime import get_runtime
def test_random_uniform(): def test_random_uniform():
runtime = get_runtime()
input_tensor = ng.constant(np.array([2, 4, 3], dtype=np.int32)) input_tensor = ng.constant(np.array([2, 4, 3], dtype=np.int32))
min_val = ng.constant(np.array([-2.7], dtype=np.float32)) min_val = ng.constant(np.array([-2.7], dtype=np.float32))
max_val = ng.constant(np.array([3.5], dtype=np.float32)) max_val = ng.constant(np.array([3.5], dtype=np.float32))
@ -15,16 +15,10 @@ def test_random_uniform():
random_uniform_node = ng.random_uniform(input_tensor, min_val, max_val, random_uniform_node = ng.random_uniform(input_tensor, min_val, max_val,
output_type="f32", global_seed=7461, output_type="f32", global_seed=7461,
op_seed=1546) op_seed=1546)
computation = runtime.computation(random_uniform_node) random_uniform_node = ng.random_uniform(input_tensor, min_val, max_val,
random_uniform_results = computation() output_type="f32", global_seed=7461,
expected_results = np.array([[[2.8450181, -2.3457108, 2.2134445], op_seed=1546)
[-1.0436587, 0.79548645, 1.3023183], assert random_uniform_node.get_output_size() == 1
[0.34447956, -2.0267959, 1.3989122], assert random_uniform_node.get_type_name() == "RandomUniform"
[0.9607613, 1.5363653, 3.117298]], assert random_uniform_node.get_output_element_type(0) == Type.f32
assert list(random_uniform_node.get_output_shape(0)) == [2, 4, 3]
[[1.570041, 2.2782724, 2.3193843],
[3.3393657, 0.63299894, 0.41231918],
[3.1739233, 0.03919673, -0.2136085],
[-1.4519991, -2.277353, 2.630727]]], dtype=np.float32)
assert np.allclose(random_uniform_results, expected_results)

135
src/bindings/python/tests_compatibility/test_ngraph/test_reduction.py
View File

@ -3,60 +3,59 @@
import numpy as np import numpy as np
import pytest import pytest
from _pyngraph import PartialShape, Dimension
import ngraph as ng import ngraph as ng
from ngraph.utils.types import make_constant_node from ngraph.impl import Type
from tests_compatibility.runtime import get_runtime
from tests_compatibility.test_ngraph.util import run_op_node
@pytest.mark.parametrize( @pytest.mark.parametrize(
"ng_api_helper, numpy_function, reduction_axes", ("ng_api_helper", "reduction_axes", "expected_shape"),
[ [
(ng.reduce_max, np.max, np.array([0, 1, 2, 3])), (ng.reduce_max, np.array([0, 1, 2, 3]), []),
(ng.reduce_min, np.min, np.array([0, 1, 2, 3])), (ng.reduce_min, np.array([0, 1, 2, 3]), []),
(ng.reduce_sum, np.sum, np.array([0, 1, 2, 3])), (ng.reduce_sum, np.array([0, 1, 2, 3]), []),
(ng.reduce_prod, np.prod, np.array([0, 1, 2, 3])), (ng.reduce_prod, np.array([0, 1, 2, 3]), []),
(ng.reduce_max, np.max, np.array([0])), (ng.reduce_max, np.array([0]), [4, 3, 2]),
(ng.reduce_min, np.min, np.array([0])), (ng.reduce_min, np.array([0]), [4, 3, 2]),
(ng.reduce_sum, np.sum, np.array([0])), (ng.reduce_sum, np.array([0]), [4, 3, 2]),
(ng.reduce_prod, np.prod, np.array([0])), (ng.reduce_prod, np.array([0]), [4, 3, 2]),
(ng.reduce_max, np.max, np.array([0, 2])), (ng.reduce_max, np.array([0, 2]), [4, 2]),
(ng.reduce_min, np.min, np.array([0, 2])), (ng.reduce_min, np.array([0, 2]), [4, 2]),
(ng.reduce_sum, np.sum, np.array([0, 2])), (ng.reduce_sum, np.array([0, 2]), [4, 2]),
(ng.reduce_prod, np.prod, np.array([0, 2])), (ng.reduce_prod, np.array([0, 2]), [4, 2]),
], ],
) )
def test_reduction_ops(ng_api_helper, numpy_function, reduction_axes): def test_reduction_ops(ng_api_helper, reduction_axes, expected_shape):
shape = [2, 4, 3, 2] shape = [2, 4, 3, 2]
np.random.seed(133391) np.random.seed(133391)
input_data = np.random.randn(*shape).astype(np.float32) input_data = np.random.randn(*shape).astype(np.float32)
expected = numpy_function(input_data, axis=tuple(reduction_axes)) node = ng_api_helper(input_data, reduction_axes)
result = run_op_node([input_data], ng_api_helper, reduction_axes) assert node.get_output_size() == 1
assert np.allclose(result, expected) assert list(node.get_output_shape(0)) == expected_shape
assert node.get_output_element_type(0) == Type.f32
@pytest.mark.parametrize( @pytest.mark.parametrize(
"ng_api_helper, numpy_function, reduction_axes", ("ng_api_helper", "reduction_axes", "expected_shape"),
[ [
(ng.reduce_logical_and, np.logical_and.reduce, np.array([0])), (ng.reduce_logical_and, np.array([0]), [4, 3, 2]),
(ng.reduce_logical_or, np.logical_or.reduce, np.array([0])), (ng.reduce_logical_or, np.array([0]), [4, 3, 2]),
(ng.reduce_logical_and, np.logical_and.reduce, np.array([0, 2])), (ng.reduce_logical_and, np.array([0, 2]), [4, 2]),
(ng.reduce_logical_or, np.logical_or.reduce, np.array([0, 2])), (ng.reduce_logical_or, np.array([0, 2]), [4, 2]),
(ng.reduce_logical_and, np.logical_and.reduce, np.array([0, 1, 2, 3])), (ng.reduce_logical_and, np.array([0, 1, 2, 3]), []),
(ng.reduce_logical_or, np.logical_or.reduce, np.array([0, 1, 2, 3])), (ng.reduce_logical_or, np.array([0, 1, 2, 3]), []),
], ],
) )
def test_reduction_logical_ops(ng_api_helper, numpy_function, reduction_axes): def test_reduction_logical_ops(ng_api_helper, reduction_axes, expected_shape):
shape = [2, 4, 3, 2] shape = [2, 4, 3, 2]
np.random.seed(133391) np.random.seed(133391)
input_data = np.random.randn(*shape).astype(bool) input_data = np.random.randn(*shape).astype(bool)
expected = numpy_function(input_data, axis=tuple(reduction_axes)) node = ng_api_helper(input_data, reduction_axes)
result = run_op_node([input_data], ng_api_helper, reduction_axes) assert node.get_output_size() == 1
assert np.allclose(result, expected) assert list(node.get_output_shape(0)) == expected_shape
assert node.get_output_element_type(0) == Type.boolean
def test_topk(): def test_topk():
@ -69,24 +68,27 @@ def test_topk():
assert node.get_output_size() == 2 assert node.get_output_size() == 2
assert list(node.get_output_shape(0)) == [6, 3, 10, 24] assert list(node.get_output_shape(0)) == [6, 3, 10, 24]
assert list(node.get_output_shape(1)) == [6, 3, 10, 24] assert list(node.get_output_shape(1)) == [6, 3, 10, 24]
assert node.get_output_element_type(0) == Type.f32
assert node.get_output_element_type(1) == Type.i32
@pytest.mark.parametrize( @pytest.mark.parametrize(
"ng_api_helper, numpy_function, reduction_axes", ("ng_api_helper", "reduction_axes", "expected_shape"),
[ [
(ng.reduce_mean, np.mean, np.array([0, 1, 2, 3])), (ng.reduce_mean, np.array([0, 1, 2, 3]), []),
(ng.reduce_mean, np.mean, np.array([0])), (ng.reduce_mean, np.array([0]), [4, 3, 2]),
(ng.reduce_mean, np.mean, np.array([0, 2])), (ng.reduce_mean, np.array([0, 2]), [4, 2]),
], ],
) )
def test_reduce_mean_op(ng_api_helper, numpy_function, reduction_axes): def test_reduce_mean_op(ng_api_helper, reduction_axes, expected_shape):
shape = [2, 4, 3, 2] shape = [2, 4, 3, 2]
np.random.seed(133391) np.random.seed(133391)
input_data = np.random.randn(*shape).astype(np.float32) input_data = np.random.randn(*shape).astype(np.float32)
expected = numpy_function(input_data, axis=tuple(reduction_axes)) node = ng_api_helper(input_data, reduction_axes)
result = run_op_node([input_data], ng_api_helper, reduction_axes) assert node.get_output_size() == 1
assert np.allclose(result, expected) assert list(node.get_output_shape(0)) == expected_shape
assert node.get_output_element_type(0) == Type.f32
def test_non_zero(): def test_non_zero():
@ -99,6 +101,7 @@ def test_non_zero():
assert node.get_type_name() == "NonZero" assert node.get_type_name() == "NonZero"
assert node.get_output_size() == 1 assert node.get_output_size() == 1
assert node.get_output_element_type(0) == Type.i64
def test_roi_align(): def test_roi_align():
@ -131,6 +134,7 @@ def test_roi_align():
assert node.get_type_name() == "ROIAlign" assert node.get_type_name() == "ROIAlign"
assert node.get_output_size() == 1 assert node.get_output_size() == 1
assert list(node.get_output_shape(0)) == expected_shape assert list(node.get_output_shape(0)) == expected_shape
assert node.get_output_element_type(0) == Type.f32
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -140,16 +144,11 @@ def test_roi_align():
def test_cum_sum(input_shape, cumsum_axis, reverse): def test_cum_sum(input_shape, cumsum_axis, reverse):
input_data = np.arange(np.prod(input_shape)).reshape(input_shape) input_data = np.arange(np.prod(input_shape)).reshape(input_shape)
if reverse:
expected = np.cumsum(input_data[::-1], axis=cumsum_axis)[::-1]
else:
expected = np.cumsum(input_data, axis=cumsum_axis)
runtime = get_runtime()
node = ng.cum_sum(input_data, cumsum_axis, reverse=reverse) node = ng.cum_sum(input_data, cumsum_axis, reverse=reverse)
computation = runtime.computation(node) assert node.get_output_size() == 1
result = computation() assert node.get_type_name() == "CumSum"
assert np.allclose(result, expected) assert list(node.get_output_shape(0)) == input_shape
assert node.get_output_element_type(0) == Type.i64
def test_normalize_l2(): def test_normalize_l2():
@ -160,38 +159,8 @@ def test_normalize_l2():
eps = 1e-6 eps = 1e-6
eps_mode = "add" eps_mode = "add"
runtime = get_runtime()
node = ng.normalize_l2(input_data, axes, eps, eps_mode) node = ng.normalize_l2(input_data, axes, eps, eps_mode)
computation = runtime.computation(node) assert node.get_output_size() == 1
result = computation() assert node.get_type_name() == "NormalizeL2"
assert list(node.get_output_shape(0)) == input_shape
expected = np.array( assert node.get_output_element_type(0) == Type.f32
[
0.01428571,
0.02857143,
0.04285714,
0.05714286,
0.07142857,
0.08571429,
0.1,
0.11428571,
0.12857144,
0.14285715,
0.15714286,
0.17142858,
0.18571429,
0.2,
0.21428572,
0.22857143,
0.24285714,
0.25714287,
0.27142859,
0.2857143,
0.30000001,
0.31428573,
0.32857144,
0.34285715,
]
).reshape(input_shape)
assert np.allclose(result, expected)

13
src/bindings/python/tests_compatibility/test_ngraph/test_roll.py
View File

@ -2,20 +2,19 @@
# SPDX-License-Identifier: Apache-2.0 # SPDX-License-Identifier: Apache-2.0
import ngraph as ng import ngraph as ng
from ngraph.impl import Type
import numpy as np import numpy as np
from tests_compatibility.runtime import get_runtime
def test_roll(): def test_roll():
runtime = get_runtime()
input = np.reshape(np.arange(10), (2, 5)) input = np.reshape(np.arange(10), (2, 5))
input_tensor = ng.constant(input) input_tensor = ng.constant(input)
input_shift = ng.constant(np.array([-10, 7], dtype=np.int32)) input_shift = ng.constant(np.array([-10, 7], dtype=np.int32))
input_axes = ng.constant(np.array([-1, 0], dtype=np.int32)) input_axes = ng.constant(np.array([-1, 0], dtype=np.int32))
roll_node = ng.roll(input_tensor, input_shift, input_axes) roll_node = ng.roll(input_tensor, input_shift, input_axes)
computation = runtime.computation(roll_node) assert roll_node.get_output_size() == 1
roll_results = computation() assert roll_node.get_type_name() == "Roll"
expected_results = np.roll(input, shift=(-10, 7), axis=(-1, 0)) assert list(roll_node.get_output_shape(0)) == [2, 5]
assert roll_node.get_output_element_type(0) == Type.i64
assert np.allclose(roll_results, expected_results)

14
src/bindings/python/tests_compatibility/test_ngraph/test_sequence_processing.py
View File

@ -4,17 +4,13 @@
import numpy as np import numpy as np
import ngraph as ng import ngraph as ng
from tests_compatibility.runtime import get_runtime from ngraph.impl import Type
from tests_compatibility.test_ngraph.util import run_op_node
def test_onehot(): def test_onehot():
runtime = get_runtime()
param = ng.parameter([3], dtype=np.int32) param = ng.parameter([3], dtype=np.int32)
model = ng.one_hot(param, 3, 1, 0, 0) model = ng.one_hot(param, 3, 1, 0, 0)
computation = runtime.computation(model, param) assert model.get_output_size() == 1
assert model.get_type_name() == "OneHot"
expected = np.eye(3)[np.array([1, 0, 2])] assert list(model.get_output_shape(0)) == [3, 3]
input_data = np.array([1, 0, 2], dtype=np.int32) assert model.get_output_element_type(0) == Type.i64
result = computation(input_data)
assert np.allclose(result, expected)

69
src/bindings/python/tests_compatibility/test_ngraph/util.py
View File

@ -1,75 +1,6 @@
# Copyright (C) 2018-2022 Intel Corporation # Copyright (C) 2018-2022 Intel Corporation
# SPDX-License-Identifier: Apache-2.0 # SPDX-License-Identifier: Apache-2.0
from typing import Any, Callable, List, Union
import numpy as np
import ngraph as ng
from ngraph.utils.types import NumericData
from tests_compatibility.runtime import get_runtime
from string import ascii_uppercase
def _get_numpy_dtype(scalar):
return np.array([scalar]).dtype
def run_op_node(input_data, op_fun, *args):
# type: (Union[NumericData, List[NumericData]], Callable, *Any) -> List[NumericData]
"""Run computation on node performing `op_fun`.
`op_fun` has to accept a node as an argument.
This function converts passed raw input data to nGraph Constant Node and that form is passed
to `op_fun`.
:param input_data: The input data for performed computation.
:param op_fun: The function handler for operation we want to carry out.
:param args: The arguments passed to operation we want to carry out.
:return: The result from computations.
"""
runtime = get_runtime()
comp_args = []
op_fun_args = []
comp_inputs = []
for idx, data in enumerate(input_data):
node = None
if np.isscalar(data):
node = ng.parameter([], name=ascii_uppercase[idx], dtype=_get_numpy_dtype(data))
else:
node = ng.parameter(data.shape, name=ascii_uppercase[idx], dtype=data.dtype)
op_fun_args.append(node)
comp_args.append(node)
comp_inputs.append(data)
op_fun_args.extend(args)
node = op_fun(*op_fun_args)
computation = runtime.computation(node, *comp_args)
return computation(*comp_inputs)
def run_op_numeric_data(input_data, op_fun, *args):
# type: (NumericData, Callable, *Any) -> List[NumericData]
"""Run computation on node performing `op_fun`.
`op_fun` has to accept a scalar or an array.
This function passess input data AS IS. This mean that in case they're a scalar (integral,
or floating point value) or a NumPy's ndarray object they will be automatically converted
to nGraph's Constant Nodes.
:param input_data: The input data for performed computation.
:param op_fun: The function handler for operation we want to carry out.
:param args: The arguments passed to operation we want to carry out.
:return: The result from computations.
"""
runtime = get_runtime()
node = op_fun(input_data, *args)
computation = runtime.computation(node)
return computation()
def count_ops_of_type(func, op_type): def count_ops_of_type(func, op_type):
count = 0 count = 0