def test_lrn():
input_image_shape = (2, 3, 2, 1)
input_image = np.arange(int(
np.prod(input_image_shape))).reshape(input_image_shape).astype("f")
axes = np.array([1], dtype=np.int64)
runtime = get_runtime()
model = ov.lrn(ov.constant(input_image),
ov.constant(axes),
alpha=1.0,
beta=2.0,
bias=1.0,
size=3)
computation = runtime.computation(model)
result = computation()
assert np.allclose(
result,
np.array(
[
[[[0.0], [0.05325444]], [[0.03402646], [0.01869806]],
[[0.06805293], [0.03287071]]],
[[[0.00509002], [0.00356153]], [[0.00174719], [0.0012555]],
[[0.00322708], [0.00235574]]],
],
dtype=np.float32,
),
)
# Test LRN default parameter values
model = ov.lrn(ov.constant(input_image), ov.constant(axes))
computation = runtime.computation(model)
result = computation()
assert np.allclose(
result,
np.array(
[
[[[0.0], [0.35355338]], [[0.8944272], [1.0606602]],
[[1.7888544], [1.767767]]],
[[[0.93704253], [0.97827977]], [[1.2493901], [1.2577883]],
[[1.5617375], [1.5372968]]],
],
dtype=np.float32,
),
)
def test_adaptive_max_pool():
runtime = get_runtime()
input = np.reshape([
0, 4, 1, 3, -2, -5, -2, -2, 1, -3, 1, -3, -4, 0, -2, 1, -1, -2, 3, -1,
-3, -1, -2, 3, 4, -3, -4, 1, 2, 0, -4, -5, -2, -2, -3, 2, 3, 1, -5, 2,
-4, -2
], (2, 3, 7))
input_tensor = ov.constant(input)
output_shape = ov.constant(np.array([3], dtype=np.int32))
adaptive_pool_node = ov.adaptive_max_pool(input_tensor, output_shape)
computation = runtime.computation(adaptive_pool_node)
adaptive_pool_results = computation()
expected_results = np.reshape(
[4, 3, -2, 1, 1, 0, 1, 3, 3, 3, 4, 1, 2, -2, -2, 3, 2, 2], (2, 3, 3))
expected_indices = np.reshape(
[1, 3, 4, 1, 3, 6, 1, 4, 4, 2, 3, 6, 0, 4, 4, 1, 4, 4], (2, 3, 3))
assert np.allclose(adaptive_pool_results,
[expected_results, expected_indices])
def test_constant_folding():
node_constant = ov.constant(
np.array([[0.0, 0.1, -0.1], [-2.5, 2.5, 3.0]], dtype=np.float32))
node_ceil = ov.ceiling(node_constant)
func = Function(node_ceil, [], "TestFunction")
assert count_ops_of_type(func, node_ceil) == 1
assert count_ops_of_type(func, node_constant) == 1
pass_manager = Manager()
pass_manager.register_pass("ConstantFolding")
pass_manager.run_passes(func)
assert count_ops_of_type(func, node_ceil) == 0
assert count_ops_of_type(func, node_constant) == 1
new_const = func.get_results()[0].input(0).get_source_output().get_node()
values_out = new_const.get_vector()
values_expected = [0.0, 1.0, 0.0, -2.0, 3.0, 3.0]
assert np.allclose(values_out, values_expected)
def test_group_convolution_backprop_data_output_shape():
runtime = get_runtime()
data_shape = [1, 1, 1, 10]
filters_shape = [1, 1, 1, 1, 5]
strides = [1, 1]
data_node = ov.parameter(data_shape, name="Data", dtype=np.float32)
filters_node = ov.parameter(filters_shape,
name="Filters",
dtype=np.float32)
output_shape_node = ov.constant(np.array([1, 14], dtype=np.int64))
model = ov.group_convolution_backprop_data(data_node,
filters_node,
strides,
output_shape_node,
auto_pad="same_upper")
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(data_shape)
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)
