def check_shape_infer(self, data_shape, indices_shape, axis, ref):
nodes = {
**shaped_parameter('data', data_shape),
**shaped_parameter('indices', indices_shape),
**regular_op_with_empty_data('gather_elements', {
'op': 'GatherElements',
'axis': axis
}),
**result()
}
graph = build_graph(nodes_attrs=nodes,
edges=[
*connect('data', '0:gather_elements'),
*connect('indices', '1:gather_elements'),
*connect('gather_elements', 'output')
],
nodes_with_edges_only=True)
graph.stage = 'middle'
gather_el_node = Node(graph, 'gather_elements')
GatherElements.infer(gather_el_node)
res_output_shape = gather_el_node.out_node().shape
self.assertTrue(strict_compare_tensors(res_output_shape, ref))
def build_and_test_shape_inference(data_shape, indices_shape, axis,
batch_dims, ref_shape):
nodes = {
**shaped_parameter('data', int64_array(data_shape)),
**shaped_parameter('indices', int64_array(indices_shape)),
**valued_const_with_data('axis', int64_array(axis)),
**regular_op_with_empty_data('gather', {
'op': 'Gather',
'batch_dims': batch_dims,
'infer': Gather.infer
}),
**result('res'),
}
edges = [
*connect('data', '0:gather'), *connect('indices', '1:gather'),
*connect('axis', '2:gather'), *connect('gather', 'res')
]
graph = build_graph(nodes, edges)
graph.stage = 'middle'
partial_infer(graph)
node = Node(graph, 'gather')
res = node.out_port(0).data.get_shape()
npt.assert_array_equal(res, ref_shape)
def build_graph_to_test_type_alignment(edges,
input_1_type=np.float32,
input_2_type=np.float32,
const_type=np.float32):
input_shape = int64_array([1, 3, 255, 255])
const_value = np.array([1], dtype=const_type)
nodes = {
**shaped_parameter('input_1', input_shape, {
'data_type': input_1_type
}),
**shaped_parameter('input_2', input_shape, {
'data_type': input_2_type
}),
**regular_op_with_empty_data('add', {
'op': 'Add',
'type': 'Add',
'type_infer': Elementwise.type_infer
}),
**valued_const_with_data('const',
const_value,
kwargs={'data_type': const_type}),
**result('result'),
}
graph = build_graph(nodes, edges, nodes_with_edges_only=True)
graph.stage = 'back'
return graph
def test_1(self):
graph = build_graph(nodes_attrs={
**shaped_parameter('input', int64_array([1, 3, 15, 15])),
**regular_op_with_empty_data('div_sqrt_dim', {
'op': '_contrib_div_sqrt_dim'
}),
**result('result')
},
edges=[
*connect('input', 'div_sqrt_dim'),
*connect('div_sqrt_dim', 'result')
])
ref_graph = build_graph(
nodes_attrs={
**shaped_parameter('input', int64_array([1, 3, 15, 15])),
**regular_op_with_empty_data('div_sqrt_shape_of', {
'op': 'ShapeOf',
'type': 'ShapeOf'
}),
**shaped_const_with_data('gather_axis', None),
**shaped_const_with_data('gather_indices', None),
**regular_op_with_empty_data('gather', {
'op': 'Gather',
'type': 'Gather'
}),
**regular_op_with_empty_data('power', {
'op': 'AttributedPower',
'power': 0.5,
'type': 'Power'
}),
**regular_op_with_empty_data('cast', {
'op': 'Cast',
'type': 'Convert',
'dst_type': np.float32
}),
**regular_op_with_empty_data('div', {
'op': 'Div',
'type': 'Divide'
}),
**result('result')
},
edges=[
*connect('input', '0:div'),
*connect_data('input', 'div_sqrt_shape_of'),
*connect('div_sqrt_shape_of', '0:gather'),
*connect('gather_axis', '1:gather'),
*connect('gather_indices', '2:gather'),
*connect('gather', 'cast'), *connect('cast', 'power'),
*connect('power', '1:div'), *connect('div', 'result')
],
)
DivSqrtDim().find_and_replace_pattern(graph)
flag, resp = compare_graphs(graph,
ref_graph,
'result',
'result',
check_op_attrs=True)
self.assertTrue(flag, resp)
def test_2(self):
graph = build_graph(
nodes_attrs={
**shaped_parameter('input', int64_array([1, 3, 15, 15])),
**regular_op_with_empty_data('layer_norm', {'op': 'LayerNorm', 'epsilon': 0.001, 'axis': 1,
'output_mean_var': False}),
**shaped_const_with_data('gamma', None),
**shaped_const_with_data('beta', None),
**result('result')
},
edges=[
*connect('input', '0:layer_norm'),
*connect('gamma', '1:layer_norm'),
*connect('beta', '2:layer_norm'),
*connect('layer_norm', 'result')
]
)
ref_graph = build_graph(
nodes_attrs={
**shaped_parameter('input', int64_array([1, 3, 15, 15])),
**shaped_const_with_data('mvn_const', None),
**regular_op_with_empty_data('mvn', {'eps': 0.001, 'across_channels': 1, 'normalize_variance': 1,
'eps_mode': 'inside_sqrt', 'op': 'MVN', 'type': 'MVN'}),
**shaped_const_with_data('gamma', None),
**regular_op_with_empty_data('gamma_unsqueeze', {'op': 'Unsqueeze', 'type': 'Unsqueeze'}),
**shaped_const_with_data('gamma_unsqueeze_const', None),
**regular_op_with_empty_data('beta_unsqueeze', {'op': 'Unsqueeze', 'type': 'Unsqueeze'}),
**shaped_const_with_data('beta_unsqueeze_const', None),
**regular_op_with_empty_data('mul', {'op': 'Mul', 'type': 'Multiply'}),
**shaped_const_with_data('beta', None),
**regular_op_with_empty_data('add', {'op': 'Add', 'type': 'Add'}),
**result('result')
},
edges=[
*connect('input', '0:mvn'),
*connect('mvn_const', '1:mvn'),
*connect('mvn', '0:mul'),
*connect('gamma', 'gamma_unsqueeze'),
*connect('gamma_unsqueeze_const', '1:gamma_unsqueeze'),
*connect('gamma_unsqueeze', '1:mul'),
*connect('mul', '0:add'),
*connect('beta', 'beta_unsqueeze'),
*connect('beta_unsqueeze_const', '1:beta_unsqueeze'),
*connect('beta_unsqueeze', '1:add'),
*connect('add', 'result')
],
update_attributes={
'mvn_const': {'value': int64_array([1]), 'shape': int64_array([1])},
'gamma_unsqueeze_const': {'value': int64_array([0, 2, 3]), 'shape': int64_array([3])},
'beta_unsqueeze_const': {'value': int64_array([0, 2, 3]), 'shape': int64_array([3])}
}
)
LayerNormalization().find_and_replace_pattern(graph)
flag, resp = compare_graphs(graph, ref_graph, 'result', 'result', check_op_attrs=True)
self.assertTrue(flag, resp)
def build_and_test_reverse_inference(inp_shape_1,
inp_shape_2,
out_shape,
ref_shape,
auto_broadcast='numpy'):
in_port_with_defined_shape = 0 if inp_shape_1 is not None else 1
defined_shape = shape_array(
inp_shape_1 if inp_shape_1 is not None else inp_shape_2)
nodes = {
**shaped_parameter('undefined_shape_data', None, {
'reverse_infer': Parameter.reverse_infer
}),
**shaped_parameter('data', shape_array(defined_shape), {
'reverse_infer': Parameter.reverse_infer
}),
**regular_op_with_empty_data(
'elementwise', {
'op': 'Add',
'type': 'Add',
'infer': eltwise_infer,
'reverse_infer': eltwise_reverse_infer,
'auto_broadcast': auto_broadcast
}),
**result('res'),
}
edges = [
*connect(
'undefined_shape_data', '{}:elementwise'.format(
int(not in_port_with_defined_shape))),
*connect('data',
'{}:elementwise'.format(in_port_with_defined_shape)),
*connect('elementwise', 'res')
]
graph = build_graph(nodes, edges)
graph.stage = 'middle'
Node(graph,
'elementwise').out_port(0).data.set_shape(shape_array(out_shape))
Node(graph, 'elementwise').in_port(
in_port_with_defined_shape).data.set_shape(defined_shape)
partial_infer(graph)
actual_shape = Node(
graph, 'undefined_shape_data').out_port(0).data.get_shape()
if ref_shape is None:
assert actual_shape == ref_shape
else:
assert strict_compare_tensors(actual_shape, shape_array(ref_shape))
def build_and_test_reverse_inference(order, out_shape, ref_shape):
nodes = {
**shaped_parameter('data', None, {
'reverse_infer': Parameter.reverse_infer
}),
**valued_const_with_data('order', int64_array(order)),
**regular_op_with_empty_data(
'transpose', {
'op': 'Transpose',
'infer': Transpose.infer,
'reverse_infer': Transpose.reverse_infer
}),
**result('res'),
}
edges = [
*connect('data', '0:transpose'), *connect('order', '1:transpose'),
*connect('transpose', 'res')
]
graph = build_graph(nodes, edges)
graph.stage = 'middle'
Node(graph,
'transpose').out_port(0).data.set_shape(shape_array(out_shape))
partial_infer(graph)
actual_shape = Node(graph, 'data').out_port(0).data.get_shape()
assert strict_compare_tensors(actual_shape, shape_array(ref_shape))
def test_negative(self):
graph = build_graph(nodes_attrs={
**shaped_parameter('input', int64_array([1, 3, 15, 15])),
**regular_op_with_empty_data(
'layer_norm', {
'op': 'LayerNorm',
'epsilon': 0.001,
'axis': -1,
'output_mean_var': True
}),
**shaped_const_with_data('gamma', None),
**shaped_const_with_data('beta', None),
**result('result'),
**result('result_1'),
**result('result_2')
},
edges=[
*connect('input', '0:layer_norm'),
*connect('gamma', '1:layer_norm'),
*connect('beta', '2:layer_norm'),
*connect('layer_norm:0', 'result'),
*connect('layer_norm:1', 'result_1'),
*connect('layer_norm:2', 'result_2')
])
with self.assertRaises(Error):
LayerNormalization().find_and_replace_pattern(graph)
def build_and_test_shape_inference(self,
input_indices_sparse_shape,
input_actual_shape,
new_shape,
ref_out_shape,
input_indices=None,
ref_out_indices=None):
# sparse tensor is stored in COO format
nodes = {
**shaped_parameter('input_indices',
shape_array(input_indices_sparse_shape), {
'value': input_indices
}),
**valued_const_with_data('input_shape',
shape_array(input_actual_shape)),
**valued_const_with_data('new_shape', shape_array(new_shape)),
**regular_op_with_empty_data(
'sparse_reshape_node', {
'op': 'SparseReshape',
'special_zero': True,
'infer': SparseReshape.infer
}),
**empty_data('sparse_reshape_node_d:out_port_1'),
**result('output_indices'),
**result('output_shape'),
}
edges = [
*connect('input_indices', '0:sparse_reshape_node'),
*connect('input_shape', '1:sparse_reshape_node'),
*connect('new_shape', '2:sparse_reshape_node'),
*connect('sparse_reshape_node:0', 'output_indices'),
('sparse_reshape_node', 'sparse_reshape_node_d:out_port_1', {
'out': 1
}),
('sparse_reshape_node_d:out_port_1', 'output_shape', {
'in': 0
}),
]
graph = build_graph(
nodes,
edges,
update_attributes={'input_indices_d': {
'value': input_indices
}})
graph.stage = 'middle'
partial_infer(graph)
node = Node(graph, 'sparse_reshape_node')
output_indices = node.out_port(0).data.get_value()
actual_output_shape = node.out_port(1).data.get_value()
self.assertTrue(
strict_compare_tensors(actual_output_shape, ref_out_shape))
self.assertTrue(strict_compare_tensors(output_indices,
ref_out_indices))
def build_and_test_reverse_inference(data_shape, indices_shape, axis,
batch_dims, out_shape, ref_shape):
in_port_with_defined_shape = 0 if data_shape is not None else 1
defined_shape = shape_array(
data_shape if data_shape is not None else indices_shape)
nodes = {
**shaped_parameter('data', data_shape, {
'reverse_infer': Parameter.reverse_infer
}),
**shaped_parameter('indices', indices_shape, {
'reverse_infer': Parameter.reverse_infer
}),
**valued_const_with_data('axis', int64_array(axis)),
**regular_op_with_empty_data(
'gather', {
'op': 'Gather',
'batch_dims': batch_dims,
'infer': Gather.infer,
'reverse_infer': Gather.reverse_infer
}),
**result('res'),
}
edges = [
*connect('data', '0:gather'), *connect('indices', '1:gather'),
*connect('axis', '2:gather'), *connect('gather', 'res')
]
graph = build_graph(nodes, edges)
graph.stage = 'middle'
Node(graph,
'gather').out_port(0).data.set_shape(shape_array(out_shape))
Node(graph, 'gather').in_port(
in_port_with_defined_shape).data.set_shape(defined_shape)
partial_infer(graph)
actual_shape = Node(graph, 'gather').in_port(
int(not in_port_with_defined_shape)).data.get_shape()
assert strict_compare_tensors(actual_shape, shape_array(ref_shape))
def test_pad_fusing_shape_subgraph(self):
nodes = {
**shaped_parameter('input', shape_array([1, 3, 1020, 1020])),
**regular_op_with_empty_data(
'input_shape', {
'type': 'ShapeOf',
'op': 'ShapeOf',
'output_type': np.int64,
'infer': Shape.infer
}),
**regular_op_with_empty_data('gathered_shape', {
'type': 'Gather',
'batch_dims': 0,
'infer': Gather.infer
}),
**valued_const_with_data('axis', np.array([0])),
**valued_const_with_data('indices', np.array([2, 3])),
**regular_op_with_empty_data(
'div', {
'type': 'Div',
'infer': lambda node: eltwise_infer(
node, lambda a, b: a / b)
}),
**regular_op_with_empty_data(
'sub_1', {
'type': 'Sub',
'infer': lambda node: eltwise_infer(
node, lambda a, b: a - b)
}),
**regular_op_with_empty_data(
'sub_2', {
'type': 'Sub',
'infer': lambda node: eltwise_infer(
node, lambda a, b: a - b)
}),
**valued_const_with_data('div_const', shape_array([2])),
**valued_const_with_data('sub_const', shape_array([512])),
**regular_op_with_empty_data('pad', {
'type': 'Pad',
'op': 'Pad',
'infer': Pad.infer,
'mode': 'constant'
}),
**regular_op_with_empty_data('concat', {
'type': 'Concat',
'op': 'Concat',
'axis': 0,
'infer': concat_infer
}),
**valued_const_with_data('pad_end', shape_array([0, 0, 0, 0])),
**valued_const_with_data('blank_zeros', shape_array([0, 0])),
**regular_op_with_empty_data(
'conv', {
'type': 'Convolution',
'op': 'Convolution',
'pad': np.array([[0, 0], [0, 0], [0, 0], [0, 0]]),
'dilation': np.array([1, 1, 1, 1]),
'stride': np.array([1, 1, 1, 1]),
'group': 1,
'kernel_spatial_idx': np.array([2, 3]),
'output': 64,
'spatial_dims': np.array([2, 3]),
'channel_dims': np.array([1]),
'batch_dims': np.array([0]),
'input_feature_channel': 1,
'output_feature_channel': 0,
'infer': Convolution.infer
}),
**valued_const_with_data('weights',
shape_array(np.zeros([3, 16, 4, 4]))),
**result(),
}
graph = build_graph(
nodes_attrs=nodes,
update_attributes={
'gathered_shape_d': {
'kind': 'data',
'value': shape_array([256, 256]),
'shape': shape_array([2])
}
},
edges=[
*connect('input', 'input_shape', skip_data=True),
*connect('input_shape', '0:gathered_shape'),
*connect('indices', '1:gathered_shape'),
*connect('axis', '2:gathered_shape'),
*connect('gathered_shape', 'sub_1'),
*connect('sub_const', 'sub_1'),
*connect('sub_1', 'div'),
*connect('div_const', 'div'),
*connect('div', '0:sub_2'),
*connect('sub_1', '1:sub_2'),
*connect('input', '0:pad'),
*connect('blank_zeros', '0:concat'),
*connect('sub_2', '1:concat'),
*connect('concat', '1:pad'),
*connect('pad_end', '2:pad'),
*connect('pad', '0:conv'),
*connect('weights', '1:conv'),
*connect('conv', 'output'),
],
nodes_with_edges_only=True)
graph.graph['layout'] = 'NCHW'
graph.stage = 'middle'
graph = partial_infer(graph)
# graph must remain unchanged
graph_ref = graph.copy()
mark_shape_of_sugraph_as_unfusable(graph)
for_graph_and_each_sub_graph_recursively(graph, fuse_pad)
(flag, resp) = compare_graphs(graph,
graph_ref,
'output',
check_op_attrs=True)
self.assertTrue(flag, resp)
import numpy as np
import unittest
from openvino.tools.mo.back.add_outputs_recursive import AddOutputRecursive
from openvino.tools.mo.ops.If import If
from openvino.tools.mo.ops.loop import Loop
from openvino.tools.mo.ops.tensor_iterator import TensorIterator
from openvino.tools.mo.front.common.partial_infer.elemental import copy_shape_infer
from openvino.tools.mo.front.common.partial_infer.utils import int64_array, dynamic_dimension_value, shape_array
from openvino.tools.mo.graph.graph import Node
from unit_tests.utils.graph import build_graph, regular_op_with_empty_data, result, connect, shaped_parameter, \
valued_const_with_data, shaped_const_with_data, regular_op_with_shaped_data
# test for Loop
main_graph_nodes = {
**shaped_parameter("IN_1", [1, 4, 64, 54]),
**shaped_parameter("IN_2", [1, 4, 64, 54]),
**valued_const_with_data("M", int64_array([5])),
**valued_const_with_data("cond", int64_array([1])),
**regular_op_with_empty_data(
"Loop", {
'op':
"Loop",
'type':
'Loop',
'sub_graphs': ['body'],
"body":
None,
'input_port_map': [{
'external_port_id': 1,
'internal_layer_id': 2,
def test_axis_not_none_start_1_step_2(self):
graph = build_graph(nodes_attrs={
**shaped_parameter('input', int64_array([1, 3, 5, 5])),
**regular_op_with_empty_data(
'arange_like', {
'op': 'arange_like',
'type': None,
'axis': 3,
'repeat': 1,
'start': 1,
'step': 2
}),
**result('result')
},
edges=[
*connect('input', 'arange_like'),
*connect('arange_like', 'result')
])
ref_graph = build_graph(
nodes_attrs={
**shaped_parameter('input', int64_array([1, 3, 5, 5])),
**regular_op_with_empty_data('shape_of', {
'op': 'ShapeOf',
'type': 'ShapeOf'
}),
**shaped_const_with_data('gather_axis', None),
**shaped_const_with_data('gather_indices', None),
**regular_op_with_empty_data('gather', {
'op': 'Gather',
'type': 'Gather'
}),
**regular_op_with_empty_data('mul', {
'op': 'Mul',
'type': 'Multiply'
}),
**shaped_const_with_data('mul_const', None),
**shaped_const_with_data('range_start', None),
**shaped_const_with_data('range_step', None),
**shaped_const_with_data('add_const', None),
**regular_op_with_empty_data('add', {
'op': 'Add',
'type': 'Add'
}),
**shaped_const_with_data('squeeze_const', None),
**regular_op_with_empty_data('squeeze', {
'op': 'Squeeze',
'type': 'Squeeze'
}),
**regular_op_with_empty_data('range', {
'op': 'Range',
'type': 'Range'
}),
**regular_op_with_empty_data('slice', {
'op': 'Slice',
'type': None
}),
**shaped_const_with_data('slice_start', None),
**shaped_const_with_data('slice_axes', None),
**shaped_const_with_data('slice_step', None),
**result('result')
},
edges=[
*connect('input', 'shape_of'),
*connect('shape_of', '0:gather'),
*connect('gather_axis', '1:gather'),
*connect('gather_indices', '2:gather'),
*connect('range_start', '0:range'),
*connect('gather', '0:mul'), *connect('mul_const', '1:mul'),
*connect('mul', '0:add'), *connect('add_const', '1:add'),
*connect('squeeze_const', '1:squeeze'),
*connect('add', '0:squeeze'), *connect('squeeze', '1:range'),
*connect('range_step', '2:range'),
*connect('range', '0:slice'),
*connect('slice_start', '1:slice'),
*connect_data('gather', '2:slice'),
*connect('slice_axes', '3:slice'),
*connect('slice_step', '4:slice'), *connect('slice', 'result')
],
update_attributes={
'gather_axis': {
'value': 3
},
'gather_indices': {
'value': 0
},
'range_start': {
'value': 1
},
'range_step': {
'value': 2
},
'add_const': {
'value': 1
},
'mul_const': {
'value': 2
},
'slice_start': {
'value': int64_array([0])
},
'slice_axes': {
'value': int64_array([0])
},
'slice_step': {
'value': int64_array([1])
},
})
ArangeLikeReplacer().find_and_replace_pattern(graph)
flag, resp = compare_graphs(graph,
ref_graph,
'result',
'result',
check_op_attrs=True)
self.assertTrue(flag, resp)
class AddReshapeTransposeAroundConvPoolTests(unittest.TestCase):
nodes = {
**shaped_parameter('input', [1, 30]),
**regular_op('splice', {
'op': 'Splice',
'context': [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
}),
**regular_op(
'conv', {
'kind': 'op',
'op': 'Convolution',
'kernel': [1, 11, 1, 5],
'patch_stride': 5,
'kernel_spatial': [1, 5]
}),
**regular_op(
'pool', {
'kind': 'op',
'op': 'Pooling',
'pool_stride': 5,
'pool_step': [1, 1, 1, 1]
}),
**regular_op('out_op', {'op': "SomeOp"}),
}
ref_nodes = {
**shaped_parameter('input', [1, 30]),
**regular_op('splice', {
'op': 'Splice',
'context': [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
}),
**regular_op('shapeof', {
'op': 'ShapeOf',
'type': 'ShapeOf'
}),
**const('ind', int64_array([0])),
**const('axis', int64_array(0)),
**regular_op('gather_batch', {
'op': 'Gather',
'type': 'Gather'
}),
**const('t', int64_array([11])),
**const('h', int64_array([5])),
**const('ind_h', int64_array([1])),
**regular_op('gather_h', {
'op': "Gather",
'type': 'Gather'
}),
**const('th', int64_array([55])),
**regular_op('div', {
'op': 'Div',
'type': 'Divide'
}),
**regular_op('concat', {
'op': 'Concat',
'type': 'Concat'
}),
**regular_op('reshape_in', {
'op': 'Reshape',
'type': 'Reshape'
}),
**const('transpose_in_order', int64_array([0, 3, 1, 2])),
**regular_op('transpose_in', {
'op': 'Transpose',
'type': 'Transpose'
}),
**regular_op('conv', {
'kind': 'op',
'op': 'Convolution',
'kernel': [1, 1, 11, 5]
}),
**regular_op(
'pool', {
'kind': 'op',
'op': 'Pooling',
'pool_stride': 5,
'pool_step': [1, 1, 1, 1]
}),
**const('transpose_out_order', int64_array([0, 2, 3, 1])),
**regular_op('transpose_out', {
'op': 'Transpose',
'type': 'Transpose'
}),
**const('reshape_out_shape', int64_array([0, -1])),
**regular_op('reshape_out', {
'op': 'Reshape',
'type': 'Reshape'
}),
**regular_op('out_op', {'op': "SomeOp"})
}
def test_simple_convolution(self):
graph = build_graph(self.nodes, [
*connect_front('input', 'splice'),
*connect_front('splice', 'conv'), *connect_front('conv', 'out_op')
],
nodes_with_edges_only=True)
graph.stage = 'front'
AddReshapeTransposeAroundConvPool.find_and_replace_pattern(graph)
ref_graph = build_graph(self.ref_nodes, [
*connect_front('input', 'splice'),
*connect_front('splice', '0:reshape_in'),
*connect_front('splice', 'shapeof'),
*connect_front('shapeof:0', '0:gather_batch'),
*connect_front('ind', '1:gather_batch'),
*connect_front('axis', '2:gather_batch'),
*connect_front('shapeof:0', '0:gather_h'),
*connect_front('ind_h', '1:gather_h'),
*connect_front('axis', '2:gather_h'),
*connect_front('gather_h', '0:div'), *connect_front('th', '1:div'),
*connect_front('gather_batch', '0:concat'),
*connect_front('t', '1:concat'), *connect_front('h', '2:concat'),
*connect_front('div', '3:concat'),
*connect_front('concat', '1:reshape_in'),
*connect_front('reshape_in', '0:transpose_in'),
*connect_front('transpose_in_order', "1:transpose_in"),
*connect_front('transpose_in', 'conv'),
*connect_front('conv', '0:transpose_out'),
*connect_front('transpose_out_order', '1:transpose_out'),
*connect_front('transpose_out', '0:reshape_out'),
*connect_front('reshape_out_shape', '1:reshape_out'),
*connect_front('reshape_out', 'out_op')
])
(flag, resp) = compare_graphs(graph,
ref_graph,
'out_op',
check_op_attrs=True)
self.assertTrue(flag, resp)
def test_simple_pooling(self):
graph = build_graph(self.nodes, [
*connect_front('input', 'splice'),
*connect_front('splice', 'pool'), *connect_front('pool', 'out_op')
],
nodes_with_edges_only=True)
graph.stage = 'front'
AddReshapeTransposeAroundConvPool.find_and_replace_pattern(graph)
ref_graph = build_graph(self.ref_nodes, [
*connect_front('input', 'splice'),
*connect_front('splice', '0:reshape_in'),
*connect_front('splice', 'shapeof'),
*connect_front('shapeof:0', '0:gather_batch'),
*connect_front('ind', '1:gather_batch'),
*connect_front('axis', '2:gather_batch'),
*connect_front('shapeof:0', '0:gather_h'),
*connect_front('ind_h', '1:gather_h'),
*connect_front('axis', '2:gather_h'),
*connect_front('gather_h', '0:div'), *connect_front('th', '1:div'),
*connect_front('gather_batch', '0:concat'),
*connect_front('t', '1:concat'), *connect_front('h', '3:concat'),
*connect_front('div', '2:concat'),
*connect_front('concat', '1:reshape_in'),
*connect_front('reshape_in', '0:transpose_in'),
*connect_front('transpose_in_order', "1:transpose_in"),
*connect_front('transpose_in', 'pool'),
*connect_front('pool', '0:transpose_out'),
*connect_front('transpose_out_order', '1:transpose_out'),
*connect_front('transpose_out', '0:reshape_out'),
*connect_front('reshape_out_shape', '1:reshape_out'),
*connect_front('reshape_out', 'out_op')
])
(flag, resp) = compare_graphs(graph,
ref_graph,
'out_op',
check_op_attrs=True)
self.assertTrue(flag, resp)
# Copyright (C) 2021 Intel Corporation
# SPDX-License-Identifier: Apache-2.0
import numpy as np
import unittest
from openvino.tools.mo.front.common.partial_infer.utils import int64_array, dynamic_dimension_value
from openvino.tools.mo.graph.graph import Node
from openvino.tools.mo.ops.Exit import Exit
from unit_tests.utils.graph import build_graph, regular_op_with_empty_data, result, connect, shaped_parameter
# test for TensorIterator
graph_nodes = {
**shaped_parameter("input", int64_array([1, 4, 64, 54])),
**regular_op_with_empty_data("exit", {'op': "Exit"}),
**result("output")
}
class ExitTest(unittest.TestCase):
def test_exit_static(self):
graph = build_graph(nodes_attrs=graph_nodes,
edges=[*connect('input', 'exit'),
*connect('exit', 'output')],
nodes_with_edges_only=True)
exit_node = Node(graph, 'exit')
in_node = Node(graph, 'input')
Exit.exit_infer(exit_node)
self.assertTrue(np.ma.allequal(exit_node.out_port(0).data.get_shape(), in_node.shape))
def test_axis_none_start_1(self):
graph = build_graph(nodes_attrs={
**shaped_parameter('input', int64_array([1, 3, 5, 5])),
**regular_op_with_empty_data(
'arange_like', {
'op': 'arange_like',
'type': None,
'axis': None,
'repeat': 1,
'start': 1,
'step': 1
}),
**result('result')
},
edges=[
*connect('input', 'arange_like'),
*connect('arange_like', 'result')
])
ref_graph = build_graph(
nodes_attrs={
**shaped_parameter('input', int64_array([1, 3, 5, 5])),
**regular_op_with_empty_data('shape_of', {
'op': 'ShapeOf',
'type': 'ShapeOf'
}),
**regular_op_with_empty_data('reduce_prod', {
'op': 'ReduceProd',
'type': 'ReduceProd'
}),
**shaped_const_with_data('reduce_prod_const', None),
**shaped_const_with_data('squeeze_const', None),
**regular_op_with_empty_data('squeeze', {
'op': 'Squeeze',
'type': 'Squeeze'
}),
**shaped_const_with_data('add_const', None),
**regular_op_with_empty_data('add', {
'op': 'Add',
'type': 'Add'
}),
**shaped_const_with_data('range_start', None),
**shaped_const_with_data('range_step', None),
**regular_op_with_empty_data('range', {
'op': 'Range',
'type': 'Range'
}),
**regular_op_with_empty_data('reshape_backward', {
'op': 'Reshape',
'type': 'Reshape'
}),
**result('result')
},
edges=[
*connect('input', 'shape_of'),
*connect('shape_of', '0:reduce_prod'),
*connect('reduce_prod_const', '1:reduce_prod'),
*connect('squeeze_const', '1:squeeze'),
*connect('add_const', '1:add'),
*connect('reduce_prod', '0:add'), *connect('add', '0:squeeze'),
*connect('range_start', '0:range'),
*connect('range_step', '2:range'),
*connect('squeeze', '1:range'),
*connect('range', '0:reshape_backward'),
*connect_data('shape_of', '1:reshape_backward'),
*connect('reshape_backward', 'result')
],
update_attributes={
'range_start': {
'value': 1
},
'range_step': {
'value': 1
},
'add_const': {
'value': 1
},
'reduce_prod_const': {
'value': int64_array([0])
}
})
ArangeLikeReplacer().find_and_replace_pattern(graph)
flag, resp = compare_graphs(graph,
ref_graph,
'result',
'result',
check_op_attrs=True)
self.assertTrue(flag, resp)
def test_pad_fusing(self):
nodes = {
**shaped_parameter('input', shape_array([1, 3, 248, 248])),
**valued_const_with_data('pads_begin', shape_array([0, 0, 1, 1])),
**valued_const_with_data('pads_end', shape_array([0, 0, 1, 1])),
**valued_const_with_data('fill_value', shape_array(0.0)),
**valued_const_with_data('weights',
shape_array(np.zeros([3, 16, 4, 4]))),
**regular_op_with_empty_data('pad', {
'type': 'Pad',
'op': 'Pad',
'infer': Pad.infer,
'mode': 'constant'
}),
**regular_op_with_empty_data(
'conv',
{
'type': 'Convolution',
'op': 'Convolution',
'infer': Convolution.infer,
# zeros, no paddings
'pad': np.array([[0, 0], [0, 0], [0, 0], [0, 0]]),
'dilation': np.array([1, 1, 1, 1]),
'stride': np.array([1, 1, 1, 1]),
'group': 1,
'kernel_spatial_idx': np.array([2, 3]),
'output': 64,
'spatial_dims': np.array([2, 3]),
'channel_dims': np.array([1]),
'batch_dims': np.array([0]),
'input_feature_channel': 1,
'output_feature_channel': 0
}),
**result(),
}
graph = build_graph(nodes_attrs=nodes,
edges=[
*connect('input', '0:pad'),
*connect('pads_begin', '1:pad'),
*connect('pads_end', '2:pad'),
*connect('fill_value', '3:pad'),
*connect('pad', '0:conv'),
*connect('weights', '1:conv'),
*connect('conv', 'output'),
],
nodes_with_edges_only=True)
graph.graph['layout'] = 'NCHW'
graph.stage = 'middle'
graph = partial_infer(graph)
mark_shape_of_sugraph_as_unfusable(graph)
for_graph_and_each_sub_graph_recursively(graph, fuse_pad)
graph.clean_up()
conv_fused_with_pad = regular_op_with_empty_data(
'conv',
{
'type': 'Convolution',
'op': 'Convolution',
# ones are taken from fused Pad
'pad': np.array([[0, 0], [0, 0], [1, 1], [1, 1]]),
'dilation': np.array([1, 1, 1, 1]),
'stride': np.array([1, 1, 1, 1]),
'group': 1,
'kernel_spatial_idx': np.array([2, 3]),
'output': 64,
'spatial_dims': np.array([2, 3]),
'channel_dims': np.array([1]),
'batch_dims': np.array([0]),
'input_feature_channel': 1,
'output_feature_channel': 0,
'infer': Convolution.infer
})
graph_ref = build_graph(nodes_attrs=nodes,
update_attributes=conv_fused_with_pad,
edges=[
*connect('input', '0:conv'),
*connect('weights', '1:conv'),
*connect('conv', 'output'),
],
nodes_with_edges_only=True)
graph_ref.graph['layout'] = 'NCHW'
graph_ref.stage = 'middle'
(flag, resp) = compare_graphs(graph,
graph_ref,
'output',
check_op_attrs=True)
self.assertTrue(flag, resp)
