def test1(self): nodes_attributes = { 'input_indices': {'shape': int64_array([5, 2]), 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter'}, 'input_values': {'shape': int64_array([5]), 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter'}, 'sparse_to_dense': {'kind': 'op', 'op': 'SparseToDense'}, 'broadcast': {'kind': 'op', 'op': 'Broadcast'}, 'scatternd': {'kind': 'op', 'op': 'ScatterNDUpdate'}, 'last': {'type': None, 'value': None, 'kind': 'op', 'op': 'Result'}, **const('input_dense_shape', int64_array([50, 40])), **const('input_default_value', int64_array(0))} graph = build_graph(nodes_attributes, [('input_indices', 'sparse_to_dense', {'out': 0, 'in': 0}), ('input_dense_shape', 'sparse_to_dense', {'out': 0, 'in': 1}), ('input_values', 'sparse_to_dense', {'out': 0, 'in': 2}), ('input_default_value', 'sparse_to_dense', {'out': 0, 'in': 3}), ('sparse_to_dense', 'last', {'out': 0, 'in': 0})], nodes_with_edges_only=True) graph.stage = 'front' SparseToDenseReplacer().find_and_replace_pattern(graph) graph_ref = build_graph(nodes_attributes, [('input_default_value', 'broadcast', {'in': 0}), ('input_dense_shape', 'broadcast', {'in': 1}), ('broadcast', 'scatternd', {'in': 0}), ('input_indices', 'scatternd', {'in': 1}), ('input_values', 'scatternd', {'in': 2}), ('scatternd', 'last', {'in': 0})], nodes_with_edges_only=True) (flag, resp) = compare_graphs(graph, graph_ref, 'last', check_op_attrs=True) self.assertTrue(flag, resp)
def setUp(self): self.start_node_name = 'StatefulPartitionedCall/Preprocessor/unstack' self.end_node_name = 'StatefulPartitionedCall/Preprocessor/stack' self.end_node_name2 = 'StatefulPartitionedCall/Preprocessor/stack2' self.loop_start_node_name = 'prefix/map/while/Preprocessor/unstack' self.loop_end_node_name = 'prefix/map/while/Preprocessor/stack' self.mul_const = float32_array([0.025, 0.374, -0.45]) self.sub_const = float32_array([2.0, 3.0, 4.0]) self.nodes = { **regular_op('input', {'type': 'Parameter'}), **regular_op('mul', {'op': 'Mul', 'type': 'Multiply', 'name': 'my_mul'}), **regular_op('sub', {'op': 'Sub', 'type': 'Subtract', 'name': 'my_sub'}), **const('mul_const', self.mul_const), **const('sub_const', self.sub_const), **regular_op(self.start_node_name, {'op': 'Identity'}), **regular_op(self.end_node_name, {'op': 'Identity'}), **regular_op(self.end_node_name2, {'op': 'Identity'}), **regular_op('loop', {'op': 'Loop', 'body': None}), **regular_op('resize', {'type': 'Interpolate'}), **result('result'), } self.replacement_desc = {'start_nodes': [self.start_node_name], 'end_nodes': [self.end_node_name, self.end_node_name2]}
def test_hsigmoid_with_relu_mul_different_tensors(self): graph = build_graph_with_edge_attrs( { **regular_op('input', {'type': 'Parameter'}), **regular_op('input_2', {'type': 'Parameter'}), **regular_op('add', {'op': 'Add'}), **regular_op('max', {'op': 'Maximum'}), **regular_op('min', {'op': 'Minimum'}), **regular_op('mul', {'op': 'Mul'}), **regular_op('mul_2', { 'op': 'Mul', 'name': 'final_mul' }), **const('const_0', float_array([0.0])), **const('const_3', float_array([3.0])), **const('const_6', float_array([6.0])), **const('const_1_6', float_array([1.0 / 6.0])), **result('result'), }, [('input_2', 'mul', { 'in': 1, 'out': 0 }), ('input', 'add', { 'in': 0, 'out': 0 }), ('const_3', 'add', { 'in': 1, 'out': 0 }), ('add', 'max', { 'in': 0, 'out': 0 }), ('const_0', 'max', { 'in': 1, 'out': 0 }), ('max', 'min', { 'in': 0, 'out': 0 }), ('const_6', 'min', { 'in': 1, 'out': 0 }), ('min', 'mul', { 'in': 0, 'out': 0 }), ('mul', 'mul_2', { 'in': 0, 'out': 0 }), ('const_1_6', 'mul_2', { 'in': 1, 'out': 0 }), ('mul_2', 'result', { 'in': 0, 'out': 0 })]) graph_ref = graph.copy() graph.stage = 'front' HSigmoidWithReluMul().find_and_replace_pattern(graph) (flag, resp) = compare_graphs(graph, graph_ref, 'result') self.assertTrue(flag, resp)
def build_body_graph(pre_processing: str): nodes = { **regular_op('input', { 'type': 'Parameter', 'op': 'Parameter' }), **regular_op('mul', { 'op': 'Mul', 'type': 'Multiply', 'name': 'my_body_mul' }), **regular_op('sub', { 'op': 'Sub', 'type': 'Subtract', 'name': 'my_body_sub' }), **const('body_mul_const', self.mul_const), **const('body_sub_const', self.sub_const), **regular_op(self.loop_start_node_name, {'op': 'Identity'}), **regular_op(self.loop_end_node_name, {'op': 'Identity'}), **regular_op('resize', {'type': 'Interpolate'}), **result('result'), } if pre_processing == 'no': edges = [ *connect_front('input', self.loop_start_node_name), *connect_front(self.loop_start_node_name, 'resize'), *connect_front('resize', self.loop_end_node_name), *connect_front(self.loop_end_node_name, 'result'), ] elif pre_processing == 'trailing': edges = [ *connect_front('input', self.loop_start_node_name), *connect_front(self.loop_start_node_name, 'resize'), *connect_front('resize', self.loop_end_node_name), *connect_front(self.loop_end_node_name, '0:mul'), *connect_front('body_mul_const', '1:mul'), *connect_front('body_sub_const', '0:sub'), *connect_front('mul', '1:sub'), *connect_front('sub', 'result'), ] else: edges = [ *connect_front('input', '0:mul'), *connect_front('body_mul_const', '1:mul'), *connect_front('body_sub_const', '0:sub'), *connect_front('mul', '1:sub'), *connect_front('sub', self.loop_start_node_name), *connect_front(self.loop_start_node_name, 'resize'), *connect_front('resize', self.loop_end_node_name), *connect_front(self.loop_end_node_name, 'result'), ] graph = build_graph(nodes, edges, nodes_with_edges_only=True) graph.stage = 'front' return graph
def test_packed(self): nodes = { **const('weights_inp', np.random.randn(100, 4)), **regular_op('indices_inp', {'type': 'Parameter'}), **regular_op('aten', {'type': None, 'kind': 'op', 'op': 'ATen', 'operator': 'embedding_bag', 'mode': 0, 'name': 'my_aten'}), **regular_op('emb_bag', {'type': 'EmbeddingBagPackedSum', 'kind': 'op', 'op': 'EmbeddingBagPackedSum'}), **result('result'), } edges = [('weights_inp', 'aten'), ('indices_inp', 'aten'), ('aten', 'result'), ] graph = build_graph(nodes, edges) graph.graph['layout'] = 'NCHW' graph.stage = 'front' edges_ref = [('weights_inp', 'emb_bag'), ('indices_inp', 'emb_bag'), ('emb_bag', 'result'), ] graph_ref = build_graph(nodes, edges_ref) AtenToEmbeddingBag().find_and_replace_pattern(graph) (flag, resp) = compare_graphs(graph, graph_ref, 'result') self.assertTrue(flag, resp)
def test(self): nodes = { **regular_op('input', {'type': 'Parameter'}), **const('depth', int64_array([2])), **regular_op('onehot', { 'type': 'OneHot', 'kind': 'op', 'op': 'OneHot' }), **regular_op('reshape', { 'type': 'Reshape', 'kind': 'op', 'op': 'Reshape' }), **const('reshape_dims', int64_array([])), **result('result'), } edges = [ ('input', 'onehot'), ('depth', 'onehot'), ('onehot', 'result'), ] graph = build_graph(nodes, edges) graph.graph['layout'] = 'NCHW' graph.stage = 'front' edges_ref = [ ('input', 'onehot'), ('depth', 'reshape'), ('reshape_dims', 'reshape'), ('reshape', 'onehot'), ('onehot', 'result'), ] graph_ref = build_graph(nodes, edges_ref) OneHotDepthNormalizer().find_and_replace_pattern(graph) (flag, resp) = compare_graphs(graph, graph_ref, 'result') self.assertTrue(flag, resp)
def test_attributed_slice_replacer(self, attributed_slice_attrs): nodes = { **regular_op_with_empty_data('input', {'type': 'Parameter'}), **regular_op_with_empty_data('attributed_slice', attributed_slice_attrs), **result(), # nodes after replacement **const('start', np.array([0, 0])), **const('end', np.array([1, -1])), **const('axis', np.array(np.array([0, 1]))), **regular_op_with_empty_data('slice', { 'op': 'Slice', 'type': None }), } graph = build_graph(nodes_attrs=nodes, edges=[ ('input', 'attributed_slice'), ('attributed_slice', 'output'), ], nodes_with_edges_only=True) graph.stage = 'front' AttributedSliceToSliceReplacer().find_and_replace_pattern(graph) graph_ref = build_graph(nodes_attrs=nodes, edges=[ ('input', 'slice'), *connect_front('start', '1:slice'), *connect_front('end', '2:slice'), *connect_front('axis', '3:slice'), ('slice', 'output'), ], nodes_with_edges_only=True) (flag, resp) = compare_graphs(graph, graph_ref, 'output', check_op_attrs=True) self.assertTrue(flag, resp)
def test2_not_applied_transform(self): # the transformation is not applied if begin and end are constant nodes_attributes = { # nodes from original graph 'input': {'type': 'Parameter', 'kind': 'op', 'op': 'Parameter'}, 'begin': {'type': 'Pack', 'kind': 'op', 'op': 'Pack'}, **const('begin_1', int64_array(0)), **const('begin_2', int64_array(0)), **const('begin_3', int64_array(0)), 'end': {'type': 'Pack', 'kind': 'op', 'op': 'Pack'}, **const('end_1', int64_array(0)), **const('end_2', int64_array(3)), **const('end_3', int64_array(0)), **const('step', int64_array([1, 1, 1])), 'strided_slice': {'type': 'StridedSlice', 'kind': 'op', 'op': 'StridedSlice', 'begin_mask': int64_array([0, 1, 0]), 'end_mask': int64_array([0, 1, 0]), 'shrink_axis_mask': int64_array([0, 1, 0]), 'name': 'non_const_begin_strided_slice'}, 'result': {'type': 'Result', 'kind': 'op', 'op': 'Result'}, } graph = build_graph(nodes_attributes, [('input', 'strided_slice', {'out': 0, 'in': 0}), ('begin_1', 'begin', {'out': 0, 'in': 0}), ('begin_2', 'begin', {'out': 0, 'in': 1}), ('begin_3', 'begin', {'out': 0, 'in': 2}), ('begin', 'strided_slice', {'out': 0, 'in': 1}), ('end_1', 'end', {'out': 0, 'in': 0}), ('end_2', 'end', {'out': 0, 'in': 1}), ('end_3', 'end', {'out': 0, 'in': 2}), ('end', 'strided_slice', {'out': 0, 'in': 2}), ('step', 'strided_slice', {'out': 0, 'in': 3}), ('strided_slice', 'result', {'out': 0, 'in': 0}), ], nodes_with_edges_only=True) graph.stage = 'front' NonConstBeginStridedSliceReplacement().find_and_replace_pattern(graph) graph_ref = build_graph(nodes_attributes, [('input', 'strided_slice', {'out': 0, 'in': 0}), ('begin_1', 'begin', {'out': 0, 'in': 0}), ('begin_2', 'begin', {'out': 0, 'in': 1}), ('begin_3', 'begin', {'out': 0, 'in': 2}), ('begin', 'strided_slice', {'out': 0, 'in': 1}), ('end_1', 'end', {'out': 0, 'in': 0}), ('end_2', 'end', {'out': 0, 'in': 1}), ('end_3', 'end', {'out': 0, 'in': 2}), ('end', 'strided_slice', {'out': 0, 'in': 2}), ('step', 'strided_slice', {'out': 0, 'in': 3}), ('strided_slice', 'result', {'out': 0, 'in': 0})], nodes_with_edges_only=True) (flag, resp) = compare_graphs(graph, graph_ref, 'result', check_op_attrs=True) self.assertTrue(flag, resp)
def build_conv_graph(): nodes = { **const('weights', np.random.randn(1, 1, 1, 1)), **regular_op('input', {'op': 'Parameter'}), **regular_op('conv', {'op': 'Conv2D', 'layout': 'NHWC'}), **result('result'), } edges = [*connect_front('input', '0:conv'), *connect_front('weights', '1:conv'), *connect_front('conv:0', 'result'), ] graph = build_graph(nodes, edges) graph.stage = 'front' return graph
class SoftplusFusionTest(unittest.TestCase): nodes = { **regular_op('input', {'type': 'Parameter'}), **regular_op('exp', {'op': 'Exp'}), **const('const_1', float_array([1.0])), **regular_op('add', {'op': 'Add'}), **regular_op('ln', {'op': 'Log', 'name': 'final_log'}), **result('result'), } edges = [('input', 'exp', {'in': 0, 'out': 0}), ('const_1', 'add', {'in': 0, 'out': 0}), ('exp', 'add', {'in': 1, 'out': 0}), ('add', 'ln', {'in': 0, 'out': 0}), ('ln', 'result', {'in': 0, 'out': 0})] def test_softplus_fusion_test(self): graph = build_graph_with_edge_attrs(self.nodes, self.edges, {}) graph_ref = build_graph(ref_nodes, ref_edges) graph.stage = 'front' SoftplusFusion().find_and_replace_pattern(graph) (flag, resp) = compare_graphs(graph, graph_ref, 'result') self.assertTrue(flag, resp) self.assertTrue(len(graph.get_op_nodes(name='final_log')) == 1 and graph.get_op_nodes(name='final_log')[0].op == 'SoftPlus') def test_softplus_fusion_test_wrong_const(self): graph = build_graph_with_edge_attrs(self.nodes, self.edges, {'const_1': {'value': float_array([0.9999])}}) graph_ref = graph.copy() graph.stage = 'front' SoftplusFusion().find_and_replace_pattern(graph) (flag, resp) = compare_graphs(graph, graph_ref, 'result') self.assertTrue(flag, resp)
class TimeheightconvolutionReplacerTest(unittest.TestCase): nodes = { **regular_op('placeholder', {}), **regular_op('timeheightconv', { 'op': 'timeheightconvolutioncomponent' }), **const('weights', int64_array([])), **const('biases', int64_array([])), **regular_op('placeholder_out', {}), **regular_op('concat', { 'type': 'Concat', 'axis': 1 }), **regular_op('memoryoffset_0', { 'type': None, 'op': 'MemoryOffset', 't': -1, 'has_default': False }), **regular_op('memoryoffset_1', { 'type': None, 'op': 'MemoryOffset', 't': 0, 'has_default': False }), **regular_op('memoryoffset_2', { 'type': None, 'op': 'MemoryOffset', 't': 1, 'has_default': True }), **regular_op( 'conv', { 'op': 'Convolution', 'type': 'Convolution', 'output': 12, 'height_in': 80 }), } def test_timeheightconvolution_1offset(self): graph = build_graph(self.nodes, [ *connect_front('placeholder', '0:timeheightconv'), *connect_front('weights', '1:timeheightconv'), *connect_front('biases', '2:timeheightconv'), *connect_front('timeheightconv', 'placeholder_out') ], nodes_with_edges_only=True) graph.stage = 'front' conv = graph.nodes['timeheightconv'] conv['height_subsample'] = 1 conv['height_in'] = 80 conv['height_out'] = 80 conv['in_channels'] = 1 conv['out_channels'] = 12 conv['offsets'] = int64_array([[-1, -1], [-1, 0], [-1, 1]]) conv['time_offsets'] = [-1] graph.nodes['weights']['value'] = np.zeros([36]) ref_graph = build_graph(self.nodes, [ *connect_front('placeholder', 'memoryoffset_0'), *connect_front('memoryoffset_0', '0:concat'), *connect_front('concat', '0:conv'), *connect_front('weights', '1:conv'), *connect_front('biases', '2:conv'), *connect_front('conv', 'placeholder_out') ], nodes_with_edges_only=True) ref_graph.nodes['weights']['value'] = np.zeros([36]) new_conv = ref_graph.nodes['conv'] new_conv['pad'] = int64_array([[0, 0], [0, 0], [0, 0], [1, 1]]) new_conv['dilation'] = int64_array([1, 1, 1, 1]) new_conv['kernel'] = int64_array([12, 1, 1, 3]) new_conv['stride'] = int64_array([1, 1, 1, 1]) ReplaceTimeHeightConvolutionPattern().find_and_replace_pattern(graph) (flag, resp) = compare_graphs(graph, ref_graph, 'placeholder_out', check_op_attrs=True) self.assertTrue(flag, resp) def test_timeheightconvolution_2_offsets(self): graph = build_graph(self.nodes, [ *connect_front('placeholder', '0:timeheightconv'), *connect_front('weights', '1:timeheightconv'), *connect_front('biases', '2:timeheightconv'), *connect_front('timeheightconv', 'placeholder_out') ], nodes_with_edges_only=True) graph.stage = 'front' conv = graph.nodes['timeheightconv'] conv['height_subsample'] = 1 conv['height_in'] = 80 conv['height_out'] = 80 conv['in_channels'] = 1 conv['out_channels'] = 12 conv['offsets'] = int64_array([[-1, -1], [-1, 0], [-1, 1], [0, -1], [0, 0], [0, 1]]) conv['time_offsets'] = int64_array([-1, 0]) graph.nodes['weights']['value'] = np.zeros([72]) ref_graph = build_graph(self.nodes, [ *connect_front('placeholder', 'memoryoffset_0'), *connect_front('placeholder', 'memoryoffset_1'), *connect_front('memoryoffset_0', '0:concat'), *connect_front('memoryoffset_1', '1:concat'), *connect_front('concat', '0:conv'), *connect_front('weights', '1:conv'), *connect_front('biases', '2:conv'), *connect_front('conv', 'placeholder_out') ], nodes_with_edges_only=True) ref_graph.nodes['weights']['value'] = np.zeros([72]) new_conv = ref_graph.nodes['conv'] new_conv['pad'] = int64_array([[0, 0], [0, 0], [0, 0], [1, 1]]) new_conv['dilation'] = int64_array([1, 1, 1, 1]) new_conv['kernel'] = int64_array([12, 1, 2, 3]) new_conv['stride'] = int64_array([1, 1, 1, 1]) ReplaceTimeHeightConvolutionPattern().find_and_replace_pattern(graph) (flag, resp) = compare_graphs(graph, ref_graph, 'placeholder_out', check_op_attrs=True) self.assertTrue(flag, resp) def test_timeheightconvolution_2_offsets_def(self): graph = build_graph(self.nodes, [ *connect_front('placeholder', '0:timeheightconv'), *connect_front('weights', '1:timeheightconv'), *connect_front('biases', '2:timeheightconv'), *connect_front('timeheightconv', 'placeholder_out') ], nodes_with_edges_only=True) graph.stage = 'front' conv = graph.nodes['timeheightconv'] conv['height_subsample'] = 1 conv['height_in'] = 80 conv['height_out'] = 80 conv['in_channels'] = 1 conv['out_channels'] = 12 conv['offsets'] = int64_array([[0, -1], [0, 0], [0, 1], [1, -1], [1, 0], [1, 1]]) conv['time_offsets'] = int64_array([0]) graph.nodes['weights']['value'] = np.zeros([72]) ref_graph = build_graph(self.nodes, [ *connect_front('placeholder', 'memoryoffset_1'), *connect_front('placeholder', 'memoryoffset_2'), *connect_front('memoryoffset_1', '0:concat'), *connect_front('memoryoffset_2', '1:concat'), *connect_front('concat', '0:conv'), *connect_front('weights', '1:conv'), *connect_front('biases', '2:conv'), *connect_front('conv', 'placeholder_out') ], nodes_with_edges_only=True) ref_graph.nodes['weights']['value'] = np.zeros([72]) new_conv = ref_graph.nodes['conv'] new_conv['pad'] = int64_array([[0, 0], [0, 0], [0, 0], [1, 1]]) new_conv['dilation'] = int64_array([1, 1, 1, 1]) new_conv['kernel'] = int64_array([12, 1, 2, 3]) new_conv['stride'] = int64_array([1, 1, 1, 1]) ReplaceTimeHeightConvolutionPattern().find_and_replace_pattern(graph) (flag, resp) = compare_graphs(graph, ref_graph, 'placeholder_out', check_op_attrs=True) self.assertTrue(flag, resp) def test_timeheightconvolution_2_offsets_dilation(self): graph = build_graph(self.nodes, [ *connect_front('placeholder', '0:timeheightconv'), *connect_front('weights', '1:timeheightconv'), *connect_front('biases', '2:timeheightconv'), *connect_front('timeheightconv', 'placeholder_out') ], nodes_with_edges_only=True) graph.stage = 'front' conv = graph.nodes['timeheightconv'] conv['height_subsample'] = 1 conv['height_in'] = 80 conv['height_out'] = 80 conv['in_channels'] = 1 conv['out_channels'] = 12 conv['offsets'] = int64_array([[-1, -3], [-1, 0], [-1, 3], [1, -3], [1, 0], [1, 3]]) conv['time_offsets'] = int64_array([-1]) graph.nodes['weights']['value'] = np.zeros([72]) ref_graph = build_graph(self.nodes, [ *connect_front('placeholder', 'memoryoffset_0'), *connect_front('placeholder', 'memoryoffset_2'), *connect_front('memoryoffset_0', '0:concat'), *connect_front('memoryoffset_2', '1:concat'), *connect_front('concat', '0:conv'), *connect_front('weights', '1:conv'), *connect_front('biases', '2:conv'), *connect_front('conv', 'placeholder_out') ], nodes_with_edges_only=True) ref_graph.nodes['weights']['value'] = np.zeros([72]) new_conv = ref_graph.nodes['conv'] new_conv['pad'] = int64_array([[0, 0], [0, 0], [0, 0], [3, 3]]) new_conv['dilation'] = int64_array([1, 1, 2, 3]) new_conv['kernel'] = int64_array([12, 1, 2, 3]) new_conv['stride'] = int64_array([1, 1, 1, 1]) ReplaceTimeHeightConvolutionPattern().find_and_replace_pattern(graph) (flag, resp) = compare_graphs(graph, ref_graph, 'placeholder_out', check_op_attrs=True) self.assertTrue(flag, resp) def test_timeheightconvolution_2_offsets_pad(self): graph = build_graph(self.nodes, [ *connect_front('placeholder', '0:timeheightconv'), *connect_front('weights', '1:timeheightconv'), *connect_front('biases', '2:timeheightconv'), *connect_front('timeheightconv', 'placeholder_out') ], nodes_with_edges_only=True) graph.stage = 'front' conv = graph.nodes['timeheightconv'] conv['height_subsample'] = 1 conv['height_in'] = 80 conv['height_out'] = 74 conv['in_channels'] = 1 conv['out_channels'] = 12 conv['offsets'] = int64_array([[-1, 0], [-1, 3], [-1, 6], [1, 0], [1, 3], [1, 6]]) conv['time_offsets'] = int64_array([-1]) graph.nodes['weights']['value'] = np.zeros([72]) ref_graph = build_graph(self.nodes, [ *connect_front('placeholder', 'memoryoffset_0'), *connect_front('placeholder', 'memoryoffset_2'), *connect_front('memoryoffset_0', '0:concat'), *connect_front('memoryoffset_2', '1:concat'), *connect_front('concat', '0:conv'), *connect_front('weights', '1:conv'), *connect_front('biases', '2:conv'), *connect_front('conv', 'placeholder_out') ], nodes_with_edges_only=True) ref_graph.nodes['weights']['value'] = np.zeros([72]) new_conv = ref_graph.nodes['conv'] new_conv['pad'] = int64_array([[0, 0], [0, 0], [0, 0], [0, 0]]) new_conv['dilation'] = int64_array([1, 1, 2, 3]) new_conv['kernel'] = int64_array([12, 1, 2, 3]) new_conv['stride'] = int64_array([1, 1, 1, 1]) ReplaceTimeHeightConvolutionPattern().find_and_replace_pattern(graph) (flag, resp) = compare_graphs(graph, ref_graph, 'placeholder_out', check_op_attrs=True) self.assertTrue(flag, resp) def test_timeheightconvolution_out_channels(self): graph = build_graph(self.nodes, [ *connect_front('placeholder', '0:timeheightconv'), *connect_front('weights', '1:timeheightconv'), *connect_front('biases', '2:timeheightconv'), *connect_front('timeheightconv', 'placeholder_out') ], nodes_with_edges_only=True) graph.stage = 'front' conv = graph.nodes['timeheightconv'] conv['height_subsample'] = 1 conv['height_in'] = 80 conv['height_out'] = 74 conv['in_channels'] = 3 conv['out_channels'] = 4 conv['offsets'] = int64_array([[-1, 0], [-1, 3], [-1, 6], [1, 0], [1, 3], [1, 6]]) conv['time_offsets'] = int64_array([-1]) graph.nodes['weights']['value'] = np.array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72 ]) ref_graph = build_graph(self.nodes, [ *connect_front('placeholder', 'memoryoffset_0'), *connect_front('placeholder', 'memoryoffset_2'), *connect_front('memoryoffset_0', '0:concat'), *connect_front('memoryoffset_2', '1:concat'), *connect_front('concat', '0:conv'), *connect_front('weights', '1:conv'), *connect_front('biases', '2:conv'), *connect_front('conv', 'placeholder_out') ], nodes_with_edges_only=True) ref_graph.nodes['weights']['value'] = np.array([ 1, 4, 7, 10, 13, 16, 2, 5, 8, 11, 14, 17, 3, 6, 9, 12, 15, 18, 19, 22, 25, 28, 31, 34, 20, 23, 26, 29, 32, 35, 21, 24, 27, 30, 33, 36, 37, 40, 43, 46, 49, 52, 38, 41, 44, 47, 50, 53, 39, 42, 45, 48, 51, 54, 55, 58, 61, 64, 67, 70, 56, 59, 62, 65, 68, 71, 57, 60, 63, 66, 69, 72 ]) new_conv = ref_graph.nodes['conv'] new_conv['output'] = 4 new_conv['pad'] = int64_array([[0, 0], [0, 0], [0, 0], [0, 0]]) new_conv['dilation'] = int64_array([1, 1, 2, 3]) new_conv['kernel'] = int64_array([4, 3, 2, 3]) new_conv['stride'] = int64_array([1, 1, 1, 1]) ReplaceTimeHeightConvolutionPattern().find_and_replace_pattern(graph) (flag, resp) = compare_graphs(graph, ref_graph, 'placeholder_out', check_op_attrs=True) self.assertTrue(flag, resp) def test_timeheightconvolution_2_offsets_stride(self): graph = build_graph(self.nodes, [ *connect_front('placeholder', '0:timeheightconv'), *connect_front('weights', '1:timeheightconv'), *connect_front('biases', '2:timeheightconv'), *connect_front('timeheightconv', 'placeholder_out') ], nodes_with_edges_only=True) graph.stage = 'front' conv = graph.nodes['timeheightconv'] conv['height_subsample'] = 2 conv['height_in'] = 80 conv['height_out'] = 37 conv['in_channels'] = 1 conv['out_channels'] = 12 conv['offsets'] = int64_array([[-1, 0], [-1, 3], [-1, 6], [1, 0], [1, 3], [1, 6]]) conv['time_offsets'] = int64_array([-1]) graph.nodes['weights']['value'] = np.zeros([72]) ref_graph = build_graph(self.nodes, [ *connect_front('placeholder', 'memoryoffset_0'), *connect_front('placeholder', 'memoryoffset_2'), *connect_front('memoryoffset_0', '0:concat'), *connect_front('memoryoffset_2', '1:concat'), *connect_front('concat', '0:conv'), *connect_front('weights', '1:conv'), *connect_front('biases', '2:conv'), *connect_front('conv', 'placeholder_out') ], nodes_with_edges_only=True) ref_graph.nodes['weights']['value'] = np.zeros([72]) new_conv = ref_graph.nodes['conv'] new_conv['pad'] = int64_array([[0, 0], [0, 0], [0, 0], [0, 0]]) new_conv['dilation'] = int64_array([1, 1, 2, 3]) new_conv['kernel'] = int64_array([12, 1, 2, 3]) new_conv['stride'] = int64_array([1, 1, 1, 2]) ReplaceTimeHeightConvolutionPattern().find_and_replace_pattern(graph) (flag, resp) = compare_graphs(graph, ref_graph, 'placeholder_out', check_op_attrs=True) self.assertTrue(flag, resp)
from extensions.front.onnx.MvnOnnxToMvn import MvnOnnxToMvn from mo.front.common.partial_infer.utils import int64_array from mo.utils.ir_engine.compare_graphs import compare_graphs from unit_tests.utils.graph import build_graph, regular_op_with_empty_data, result, const, connect_front nodes = { **regular_op_with_empty_data('input', {'type': 'Parameter'}), **regular_op_with_empty_data('mvn_onnx', {'op': 'MVNOnnx', 'axes': int64_array([2, 3]), 'eps': 1e-9, 'eps_mode': 'outside_sqrt', 'normalize_variance': 1}), **result(), # nodes after replacement **const('axes', int64_array([2, 3])), **regular_op_with_empty_data('mvn', {'op': 'MVN', 'type': None}), } class MvnOnnxToMvnTest(unittest.TestCase): def test_mvn_normalize(self): graph = build_graph(nodes, [('input', 'mvn_onnx'), ('mvn_onnx', 'output')], nodes_with_edges_only=True) graph.stage = 'front' MvnOnnxToMvn().find_and_replace_pattern(graph) graph_ref = build_graph(nodes, [('input', 'mvn'), *connect_front('axes', '1:mvn'),
from unit_tests.utils.graph import build_graph, const, result, regular_op nodes_attributes = { **regular_op('placeholder', {'type': 'Parameter'}), **regular_op( 'attr_roll', { 'type': 'AttributedRoll', 'op': 'AttributedRoll', 'axes': int64_array([-1, 2, 3]), 'shift': int64_array([5, -2, 3]) }), **result('result'), # new Roll node and inputs **regular_op('roll', {'type': 'Roll'}), **const('roll_axes', int64_array([-1, 2, 3])), **const('roll_shift', int64_array([5, -2, 3])) } class AttributedRollToRollTest(unittest.TestCase): def test_axes_shift(self): graph = build_graph(nodes_attributes, [('placeholder', 'attr_roll', { 'in': 0, 'out': 0 }), ('attr_roll', 'result', { 'in': 0, 'out': 0 })], {}, nodes_with_edges_only=True)
from extensions.front.AttributedRandomUniformToRandomUniform import AttributedRandomUniformToRandomUniform from mo.front.common.partial_infer.utils import int64_array, float32_array from mo.utils.ir_engine.compare_graphs import compare_graphs from unit_tests.utils.graph import build_graph, const, result, regular_op nodes = { **regular_op('placeholder', {'type': 'Parameter'}), **regular_op('attr_random_uniform', {'type': 'AttributedRandomUniform', 'op': 'AttributedRandomUniform', 'output_type': np.float32, 'min_val': float32_array([-1.5]), 'max_val': float32_array([10.7]), 'shape': int64_array([5, 4, 3])}), **result('result'), # new RandomUniform node and inputs **regular_op('random_uniform', {'type': 'RandomUniform'}), **const('min_val', float32_array([-1.5])), **const('max_val', float32_array([10.7])), **const('shape', int64_array([5, 4, 3])), } class AttributedRandomUniformToRandomUniformTest(unittest.TestCase): def test_min_max(self): graph = build_graph(nodes, [('placeholder', 'attr_random_uniform', {'in': 0, 'out': 0}), ('attr_random_uniform', 'result', {'in': 0, 'out': 0})], {}, nodes_with_edges_only=True) graph_ref = build_graph(nodes, [('placeholder', 'random_uniform', {'in': 0, 'out': 0}), ('min_val', 'random_uniform', {'in': 1, 'out': 0}), ('max_val', 'random_uniform', {'in': 2, 'out': 0}),
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)
def test2(self): nodes_attributes = { 'input_indices': { 'shape': int64_array([5, 2]), 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter' }, 'input_values': { 'shape': int64_array([5]), 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter' }, 'input_dense_shape': { 'shape': int64_array([2]), 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter' }, 'input_params_table': { 'shape': int64_array([10, 3, 4]), 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter' }, 'input_default_value': { 'shape': int64_array([]), 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter' }, 'identity_spw': { 'kind': 'op', 'op': 'Identity' }, 'gather0_1': { 'kind': 'op', 'op': 'Gather', 'type': 'Gather' }, 'gather0_2': { 'kind': 'op', 'op': 'Gather', 'type': 'Gather' }, 'reshape0': { 'kind': 'op', 'op': 'Reshape' }, 'where0': { 'kind': 'op', 'op': 'Where' }, 'greaterequal0': { 'kind': 'op', 'op': 'GreaterEqual' }, 'sparse_fill_empty_rows': { 'kind': 'op', 'op': 'SparseFillEmptyRows' }, 'unique': { 'kind': 'op', 'op': 'Unique' }, 'strided_slice': { 'kind': 'op', 'op': 'StridedSlice' }, 'cast': { 'kind': 'op', 'op': 'Cast' }, 'gather': { 'kind': 'op', 'op': 'Gather', 'type': 'Gather' }, 'identity': { 'kind': 'op', 'op': 'Identity' }, 'identity_1': { 'kind': 'op', 'op': 'Identity' }, 'sparse_segment_mean': { 'kind': 'op', 'op': 'SparseSegmentMean' }, 'reshape': { 'kind': 'op', 'op': 'Reshape' }, 'tile': { 'kind': 'op', 'op': 'Tile', 'type': 'Tile' }, 'select': { 'kind': 'op', 'op': 'Select' }, 'split_for_indices': { 'kind': 'op', 'op': 'Split' }, 'squeeze_for_indices': { 'kind': 'op', 'op': 'Squeeze' }, 'split_for_dense_shape': { 'kind': 'op', 'op': 'Split' }, 'squeeze_to_scalar': { 'kind': 'op', 'op': 'Squeeze' }, 'cast_indices': { 'kind': 'op', 'op': 'Cast' }, 'cast_segment_ids': { 'kind': 'op', 'op': 'Cast' }, 'cast_default_value': { 'kind': 'op', 'op': 'Cast' }, 'cast_number_segments': { 'kind': 'op', 'op': 'Cast' }, 'embedding_segments_mean': { 'kind': 'op', 'op': 'EmbeddingSegmentsMean' }, **const('split_for_indices_axis', int64_array(1)), **const('split_for_dense_shape_axis', int64_array(0)), **const('squeeze_axis', int64_array([0])), **const('squeeze_for_indices_axis', int64_array([1])), 'last': { 'type': None, 'value': None, 'kind': 'op', 'op': 'Result' }, } graph = build_graph( nodes_attributes, [('input_indices', 'gather0_1', { 'out': 0, 'in': 0 }), ('input_dense_shape', 'identity_spw', { 'out': 0, 'in': 0 }), ('input_values', 'greaterequal0', { 'out': 0, 'in': 0 }), ('input_values', 'gather0_2', { 'out': 0, 'in': 0 }), ('input_params_table', 'gather', { 'out': 0, 'in': 0 }), ('input_default_value', 'sparse_fill_empty_rows', { 'out': 0, 'in': 3 }), ('identity_spw', 'sparse_fill_empty_rows', { 'out': 0, 'in': 2 }), ('gather0_1', 'sparse_fill_empty_rows', { 'out': 0, 'in': 0 }), ('gather0_2', 'sparse_fill_empty_rows', { 'out': 0, 'in': 1 }), ('reshape0', 'gather0_1', { 'out': 0, 'in': 1 }), ('reshape0', 'gather0_2', { 'out': 0, 'in': 1 }), ('where0', 'reshape0', { 'out': 0, 'in': 0 }), ('greaterequal0', 'where0', { 'out': 0, 'in': 0 }), ('sparse_fill_empty_rows', 'unique', { 'out': 1, 'in': 0 }), ('sparse_fill_empty_rows', 'strided_slice', { 'out': 0, 'in': 0 }), ('sparse_fill_empty_rows', 'reshape', { 'out': 2, 'in': 0 }), ('unique', 'sparse_segment_mean', { 'out': 1, 'in': 1 }), ('unique', 'gather', { 'out': 0, 'in': 1 }), ('strided_slice', 'cast', { 'out': 0, 'in': 0 }), ('gather', 'identity', { 'out': 0, 'in': 0 }), ('identity', 'identity_1', { 'out': 0, 'in': 0 }), ('identity_1', 'sparse_segment_mean', { 'out': 0, 'in': 0 }), ('cast', 'sparse_segment_mean', { 'out': 0, 'in': 2 }), ('sparse_segment_mean', 'select', { 'out': 0, 'in': 2 }), ('reshape', 'tile', { 'out': 0, 'in': 0 }), ('tile', 'select', { 'out': 0, 'in': 0 }), ('select', 'last', { 'out': 0, 'in': 0 })], nodes_with_edges_only=True) graph.stage = 'front' EmbeddingSegmentsOperationMultipleFeaturesFusing( ).find_and_replace_pattern(graph) graph_ref = build_graph(nodes_attributes, [ ('input_indices', 'split_for_indices', { 'in': 0 }), ('split_for_indices_axis', 'split_for_indices', { 'in': 1 }), ('split_for_indices', 'squeeze_for_indices', { 'in': 0 }), ('squeeze_for_indices_axis', 'squeeze_for_indices', { 'in': 1 }), ('squeeze_for_indices', 'cast_segment_ids', { 'in': 0 }), ('cast_segment_ids', 'embedding_segments_mean', { 'in': 2, 'out': 0 }), ('input_values', 'cast_indices', { 'in': 0 }), ('cast_indices', 'embedding_segments_mean', { 'in': 1 }), ('input_dense_shape', 'split_for_dense_shape', { 'in': 0 }), ('split_for_dense_shape_axis', 'split_for_dense_shape', { 'in': 1 }), ('split_for_dense_shape', 'squeeze_to_scalar', { 'in': 0 }), ('squeeze_axis', 'squeeze_to_scalar', { 'in': 1 }), ('squeeze_to_scalar', 'cast_number_segments', { 'in': 0 }), ('cast_number_segments', 'embedding_segments_mean', { 'in': 3, 'out': 0 }), ('input_params_table', 'embedding_segments_mean', { 'in': 0 }), ('input_default_value', 'cast_default_value', { 'in': 0 }), ('cast_default_value', 'embedding_segments_mean', { 'in': 4 }), ('embedding_segments_mean', 'last', { 'in': 0 }), ], nodes_with_edges_only=True) (flag, resp) = compare_graphs(graph, graph_ref, 'last', check_op_attrs=True) self.assertTrue(flag, resp)
from openvino.tools.mo.utils.ir_engine.compare_graphs import compare_graphs from unit_tests.utils.graph import build_graph, regular_op, result, build_graph_with_edge_attrs, const nodes = { **regular_op('input', {'type': 'Parameter'}), **regular_op('relu', {'type': 'Relu'}), **regular_op('pooling', { 'type': 'Pooling', 'global_pool': True, 'pool_method': 'avg' }), **result('result'), **regular_op('rank', {'type': 'Rank'}), **regular_op('reduce_mean', {'type': 'ReduceMean'}), **regular_op('range', {'type': 'Range'}), **const('const_1', int64_array(2)), **const('const_2', int64_array(1)), } edges = [('input', 'relu', { 'in': 0, 'out': 0 }), ('relu', 'pooling', { 'in': 0, 'out': 0 }), ('pooling', 'result', { 'in': 0, 'out': 0 })] ref_edges = [('input', 'relu', { 'in': 0, 'out': 0
import numpy as np from generator import generator, generate from openvino.tools.mo.front.tf.CorrectPaddingsForPadAfterComplex import CorrectPaddingsForPadAfterComplex from openvino.tools.mo.front.common.partial_infer.utils import int64_array from openvino.tools.mo.utils.ir_engine.compare_graphs import compare_graphs from unit_tests.utils.graph import build_graph, const graph_node_attrs = { 'placeholder_real': {'shape': int64_array([3, 100, 67]), 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter'}, 'placeholder_imag': {'shape': int64_array([3, 100, 67]), 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter'}, 'complex': {'kind': 'op', 'op': 'Complex'}, 'pad': {'type': 'Pad', 'kind': 'op', 'op': 'Pad', 'mode': 'constant'}, **const('pad_begin', int64_array([1, 3, 5])), **const('pad_end', int64_array([2, 4, 6])), 'abs': {'type': 'Abs', 'kind': 'op', 'op': 'Abs'}, 'output': {'type': None, 'value': None, 'kind': 'op', 'op': 'Result'}, } graph_edges = [ ('placeholder_real', 'complex', {'in': 0}), ('placeholder_imag', 'complex', {'in': 1}), ('complex', 'pad', {'in': 0, 'out': 0}), ('pad_begin', 'pad', {'in': 1, 'out': 0}), ('pad_end', 'pad', {'in': 2, 'out': 0}), ('pad', 'abs'), ('abs', 'output'), ]
def test1(self): nodes_attributes = { # nodes from original graph 'input': { 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter' }, 'index': { 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter' }, 'add': { 'type': 'Add', 'kind': 'op', 'op': 'Add' }, **const('slice_size', int64_array(1)), 'begin': { 'type': 'Pack', 'kind': 'op', 'op': 'Pack' }, **const('begin_1', int64_array(0)), **const('begin_3', int64_array(0)), 'end': { 'type': 'Pack', 'kind': 'op', 'op': 'Pack' }, **const('end_1', int64_array(0)), **const('end_3', int64_array(0)), **const('step', int64_array([1, 1, 1])), 'strided_slice': { 'type': 'StridedSlice', 'kind': 'op', 'op': 'StridedSlice', 'begin_mask': int64_array([0, 1, 0]), 'end_mask': int64_array([0, 1, 0]), 'shrink_axis_mask': int64_array([0, 1, 0]), 'name': 'non_const_begin_strided_slice' }, 'result': { 'type': 'Result', 'kind': 'op', 'op': 'Result' }, # nodes from the reference graph 'unsqueeze': { 'type': 'Unsqueeze', 'kind': 'op', 'op': 'Unsqueeze' }, **const('unsqueeze_axis', int64_array(0)), 'gather': { 'type': 'Gather', 'kind': 'op', 'op': 'Gather' }, **const('gather_axis', int64_array(1)), 'squeeze': { 'type': 'Squeeze', 'kind': 'op', 'op': 'Squeeze' }, **const('squeeze_axis', int64_array(1)), } graph = build_graph(nodes_attributes, [ ('input', 'strided_slice', { 'out': 0, 'in': 0 }), ('begin_1', 'begin', { 'out': 0, 'in': 0 }), ('index', 'begin', { 'out': 0, 'in': 1 }), ('begin_3', 'begin', { 'out': 0, 'in': 2 }), ('begin', 'strided_slice', { 'out': 0, 'in': 1 }), ('end_1', 'end', { 'out': 0, 'in': 0 }), ('index', 'add', { 'out': 0, 'in': 0 }), ('slice_size', 'add', { 'out': 0, 'in': 1 }), ('add', 'end', { 'out': 0, 'in': 1 }), ('end_3', 'end', { 'out': 0, 'in': 2 }), ('end', 'strided_slice', { 'out': 0, 'in': 2 }), ('step', 'strided_slice', { 'out': 0, 'in': 3 }), ('strided_slice', 'result', { 'out': 0, 'in': 0 }), ], nodes_with_edges_only=True) graph.stage = 'front' NonConstBeginStridedSliceReplacement().find_and_replace_pattern(graph) graph_ref = build_graph(nodes_attributes, [ ('input', 'gather', { 'out': 0, 'in': 0 }), ('gather_axis', 'gather', { 'out': 0, 'in': 2 }), ('index', 'unsqueeze', { 'out': 0, 'in': 0 }), ('unsqueeze_axis', 'unsqueeze', { 'out': 0, 'in': 1 }), ('unsqueeze', 'gather', { 'out': 0, 'in': 1 }), ('gather', 'squeeze', { 'out': 0, 'in': 0 }), ('squeeze_axis', 'squeeze', { 'out': 0, 'in': 1 }), ('squeeze', 'result', { 'out': 0, 'in': 0 }), ], nodes_with_edges_only=True) (flag, resp) = compare_graphs(graph, graph_ref, 'result', check_op_attrs=True) self.assertTrue(flag, resp) self.assertTrue(graph.node[graph.get_nodes_with_attributes( op='Squeeze')[0]]['name'] == 'non_const_begin_strided_slice')
def test2(self): nodes_attributes = { # nodes from original graph 'logits': { 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter' }, 'seq_len': { 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter' }, 'order_arr': { 'kind': 'op', 'op': 'Const' }, 'transpose': { 'type': 'Transpose', 'kind': 'op', 'op': 'Transpose' }, 'decoder': { 'kind': 'op', 'op': 'CTCGreedyDecoderSeqLen', 'merge_repeated': True }, 'cast': { 'kind': 'op', 'op': 'Cast' }, 'sparse_to_dense': { 'kind': 'op', 'op': 'SparseToDense' }, 'last': { 'type': None, 'value': None, 'kind': 'op', 'op': 'Result' }, # new nodes 'new_decoder': { 'kind': 'op', 'op': 'CTCGreedyDecoderSeqLen', 'use_mask_format': True }, **const('squeeze_axes', int64_array([2, 3])), 'squeeze_dec_seq': { 'kind': 'op', 'op': 'Squeeze' }, 'cast_to_int': { 'kind': 'op', 'op': 'Cast' }, } graph = build_graph(nodes_attributes, [ ('logits', 'decoder', { 'out': 0, 'in': 0 }), ('seq_len', 'decoder', { 'out': 0, 'in': 1 }), ('decoder', 'sparse_to_dense', { 'out': 0, 'in': 0 }), ('decoder', 'cast', { 'out': 1, 'in': 0 }), ('cast', 'sparse_to_dense', { 'out': 0 }), ('sparse_to_dense', 'last', { 'out': 0, 'in': 0 }), ], nodes_with_edges_only=True) graph.stage = 'front' CTCGreedyDecoderReplacement().find_and_replace_pattern(graph) graph_ref = build_graph(nodes_attributes, [ ('logits', 'transpose', { 'out': 0, 'in': 0 }), ('order_arr', 'transpose', { 'out': 0, 'in': 1 }), ('transpose', 'decoder', { 'out': 0, 'in': 0 }), ('seq_len', 'decoder', { 'out': 0, 'in': 1 }), ('decoder', 'last', { 'out': 0, 'in': 0 }), ], nodes_with_edges_only=True) (flag, resp) = compare_graphs(graph, graph_ref, 'last', check_op_attrs=True) self.assertTrue(flag, resp)
class CTCLossFrontReplacementTest(unittest.TestCase): nodes_attributes = { 'logits': { 'shape': int64_array([2, 6, 100]), 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter' }, 'seq_mask': { 'shape': int64_array([2]), 'data_type': np.int32, 'kind': 'op', 'op': 'Parameter' }, 'transpose': { 'kind': 'op', 'op': 'Transpose' }, 'ctc_greedy_decoder': { 'kind': 'op', 'op': 'CTCGreedyDecoderSeqLen', 'merge_repeated': True, 'output_sparse_format': True }, 'cast': { 'kind': 'op', 'op': 'Cast' }, 'sparse_to_dense': { 'kind': 'op', 'op': 'SparseToDense' }, 'tf_ctc_loss_true_logits': { 'kind': 'op', 'op': 'CTCLoss', 'preprocess_collapse_repeated': False, 'ctc_merge_repeated': True, 'unique': False, 'logits_time_major': True }, 'tf_ctc_loss_false_logits': { 'kind': 'op', 'op': 'CTCLoss', 'preprocess_collapse_repeated': False, 'ctc_merge_repeated': True, 'unique': False, 'logits_time_major': False }, 'ctc_loss': { 'kind': 'op', 'op': 'CTCLoss', 'preprocess_collapse_repeated': False, 'ctc_merge_repeated': True, 'unique': False }, **const('default_value', int64_array(-1)), 'last': { 'type': None, 'value': None, 'kind': 'op', 'op': 'Result' }, 'transpose2': { 'kind': 'op', 'op': 'Transpose' }, **const('transpose2_axis', int64_array([1, 0, 2])), 'new_ctc_greedy_decoder': { 'kind': 'op', 'op': 'CTCGreedyDecoderSeqLen', 'merge_repeated': True }, } def CTCLossReplacement_test_true_logits(self): graph = build_graph( self.nodes_attributes, [('logits', 'transpose', { 'out': 0, 'in': 0 }), ('transpose', 'ctc_greedy_decoder', { 'out': 0, 'in': 0 }), ('seq_mask', 'ctc_greedy_decoder', { 'out': 0, 'in': 1 }), ('transpose', 'tf_ctc_loss_true_logits', { 'out': 0, 'in': 0 }), ('seq_mask', 'tf_ctc_loss_true_logits', { 'out': 0, 'in': 3 }), ('ctc_greedy_decoder', 'sparse_to_dense', { 'out': 0, 'in': 0 }), ('ctc_greedy_decoder', 'sparse_to_dense', { 'out': 2, 'in': 1 }), ('ctc_greedy_decoder', 'sparse_to_dense', { 'out': 1, 'in': 2 }), ('default_value', 'sparse_to_dense', { 'out': 0, 'in': 3 }), ('ctc_greedy_decoder', 'cast', { 'out': 1, 'in': 0 }), ('ctc_greedy_decoder', 'tf_ctc_loss_true_logits', { 'out': 0, 'in': 1 }), ('cast', 'tf_ctc_loss_true_logits', { 'out': 0, 'in': 2 }), ('tf_ctc_loss_true_logits', 'last', { 'out': 0, 'in': 0 })], nodes_with_edges_only=True) graph.graph['cmd_params'] = Namespace(data_type='FP32') graph.stage = 'front' CTCLossReplacement().find_and_replace_pattern(graph) graph_ref = build_graph(self.nodes_attributes, [('logits', 'transpose', { 'out': 0, 'in': 0 }), ('transpose', 'transpose2', { 'out': 0, 'in': 0 }), ('transpose2_axis', 'transpose2', { 'out': 0, 'in': 1 }), ('transpose2', 'new_ctc_greedy_decoder', { 'out': 0, 'in': 0 }), ('seq_mask', 'new_ctc_greedy_decoder', { 'out': 0, 'in': 1 }), ('transpose2', 'ctc_loss', { 'out': 0, 'in': 0 }), ('new_ctc_greedy_decoder', 'ctc_loss', { 'out': 0, 'in': 2 }), ('new_ctc_greedy_decoder', 'ctc_loss', { 'out': 1, 'in': 3 }), ('seq_mask', 'ctc_loss', { 'out': 0, 'in': 1 }), ('ctc_loss', 'last', { 'out': 0, 'in': 0 })], nodes_with_edges_only=True) (flag, resp) = compare_graphs(graph, graph_ref, 'last', check_op_attrs=True) self.assertTrue(flag, resp) def CTCLossReplacement_test_false_logits(self): graph = build_graph( self.nodes_attributes, [('logits', 'transpose', { 'out': 0, 'in': 0 }), ('transpose', 'ctc_greedy_decoder', { 'out': 0, 'in': 0 }), ('seq_mask', 'ctc_greedy_decoder', { 'out': 0, 'in': 1 }), ('transpose', 'tf_ctc_loss_false_logits', { 'out': 0, 'in': 0 }), ('seq_mask', 'tf_ctc_loss_false_logits', { 'out': 0, 'in': 3 }), ('ctc_greedy_decoder', 'sparse_to_dense', { 'out': 0, 'in': 0 }), ('ctc_greedy_decoder', 'sparse_to_dense', { 'out': 2, 'in': 1 }), ('ctc_greedy_decoder', 'sparse_to_dense', { 'out': 1, 'in': 2 }), ('default_value', 'sparse_to_dense', { 'out': 0, 'in': 3 }), ('ctc_greedy_decoder', 'cast', { 'out': 1, 'in': 0 }), ('ctc_greedy_decoder', 'tf_ctc_loss_false_logits', { 'out': 0, 'in': 1 }), ('cast', 'tf_ctc_loss_false_logits', { 'out': 0, 'in': 2 }), ('tf_ctc_loss_false_logits', 'last', { 'out': 0, 'in': 0 })], nodes_with_edges_only=True) graph.graph['cmd_params'] = Namespace(data_type='FP32') graph.stage = 'front' CTCLossReplacement().find_and_replace_pattern(graph) graph_ref = build_graph(self.nodes_attributes, [('logits', 'transpose', { 'out': 0, 'in': 0 }), ('transpose', 'transpose2', { 'out': 0, 'in': 0 }), ('transpose2_axis', 'transpose2', { 'out': 0, 'in': 1 }), ('transpose2', 'new_ctc_greedy_decoder', { 'out': 0, 'in': 0 }), ('seq_mask', 'new_ctc_greedy_decoder', { 'out': 0, 'in': 1 }), ('transpose', 'ctc_loss', { 'out': 0, 'in': 0 }), ('new_ctc_greedy_decoder', 'ctc_loss', { 'out': 0, 'in': 2 }), ('new_ctc_greedy_decoder', 'ctc_loss', { 'out': 1, 'in': 3 }), ('seq_mask', 'ctc_loss', { 'out': 0, 'in': 1 }), ('ctc_loss', 'last', { 'out': 0, 'in': 0 })], nodes_with_edges_only=True) (flag, resp) = compare_graphs(graph, graph_ref, 'last', check_op_attrs=True) self.assertTrue(flag, resp)
'type': 'Greater', 'kind': 'op', 'op': 'Greater' }, 'mul': { 'type': 'Multiply', 'kind': 'op', 'op': 'Mul', 'name': 'my_trelu' }, 'squeeze2': { 'type': 'Squeeze', 'kind': 'op', 'op': 'Squeeze' }, **const('alpha', float_array([0.75])), } class ThresholdedReluDecompositionTest(unittest.TestCase): def test_trelu(self): graph = build_graph(nodes_attributes, [ ('parameter', 'trelu', { 'in': 0, 'out': 0 }), ('trelu', 'result', { 'in': 0, 'out': 0 }), ],
class CTCGreedyDecoderReplacementTests(unittest.TestCase): nodes_attributes = { # nodes from original graph 'logits': { 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter' }, 'seq_len': { 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter' }, 'order_arr': { 'kind': 'op', 'op': 'Const' }, 'transpose': { 'type': 'Transpose', 'kind': 'op', 'op': 'Transpose' }, 'decoder': { 'kind': 'op', 'op': 'CTCGreedyDecoderSeqLen', 'merge_repeated': True, 'output_sparse_format': True }, 'cast': { 'kind': 'op', 'op': 'Cast' }, 'sparse_to_dense': { 'kind': 'op', 'op': 'SparseToDense' }, 'last': { 'type': None, 'value': None, 'kind': 'op', 'op': 'Result' }, 'last_1': { 'type': None, 'value': None, 'kind': 'op', 'op': 'Result' }, # new nodes 'new_decoder': { 'kind': 'op', 'op': 'CTCGreedyDecoderSeqLen', 'merge_repeated': True }, **const('squeeze_axes', int64_array([2, 3])), 'squeeze_dec_seq': { 'kind': 'op', 'op': 'Squeeze' }, 'cast_to_int': { 'kind': 'op', 'op': 'Cast' }, 'out_seq_len': { 'type': None, 'value': None, 'kind': 'op', 'op': 'Result' }, } def test_CTCGreedyDecoderWithSparseToDenseShape(self): graph = build_graph(self.nodes_attributes, [ ('logits', 'decoder', { 'out': 0, 'in': 0 }), ('seq_len', 'decoder', { 'out': 0, 'in': 1 }), ('decoder', 'sparse_to_dense', { 'out': 0, 'in': 0 }), ('decoder', 'sparse_to_dense', { 'out': 2, 'in': 1 }), ('decoder', 'cast', { 'out': 1, 'in': 0 }), ('cast', 'sparse_to_dense', { 'out': 0 }), ('sparse_to_dense', 'last', { 'out': 0, 'in': 0 }), ], nodes_with_edges_only=True) graph.stage = 'front' CTCGreedyDecoderWithSparseToDenseShapeReplacement( ).find_and_replace_pattern(graph) graph_ref = build_graph(self.nodes_attributes, [ ('logits', 'transpose', { 'out': 0, 'in': 0 }), ('order_arr', 'transpose', { 'out': 0, 'in': 1 }), ('transpose', 'new_decoder', { 'out': 0, 'in': 0 }), ('seq_len', 'new_decoder', { 'out': 0, 'in': 1 }), ('new_decoder', 'last', { 'out': 0, 'in': 0 }), ], nodes_with_edges_only=True) (flag, resp) = compare_graphs(graph, graph_ref, 'last', check_op_attrs=True) self.assertTrue(flag, resp) def test_CTCGreedyDecoderReplacement(self): graph = build_graph(self.nodes_attributes, [ ('logits', 'decoder', { 'out': 0, 'in': 0 }), ('seq_len', 'decoder', { 'out': 0, 'in': 1 }), ('decoder', 'sparse_to_dense', { 'out': 0, 'in': 0 }), ('decoder', 'cast', { 'out': 1, 'in': 0 }), ('cast', 'sparse_to_dense', { 'out': 0 }), ('sparse_to_dense', 'last', { 'out': 0, 'in': 0 }), ], nodes_with_edges_only=True) graph.stage = 'front' CTCGreedyDecoderReplacement().find_and_replace_pattern(graph) graph_ref = build_graph(self.nodes_attributes, [ ('logits', 'transpose', { 'out': 0, 'in': 0 }), ('order_arr', 'transpose', { 'out': 0, 'in': 1 }), ('transpose', 'new_decoder', { 'out': 0, 'in': 0 }), ('seq_len', 'new_decoder', { 'out': 0, 'in': 1 }), ('new_decoder', 'last', { 'out': 0, 'in': 0 }), ], nodes_with_edges_only=True) (flag, resp) = compare_graphs(graph, graph_ref, 'last', check_op_attrs=True) self.assertTrue(flag, resp) def test_CTCGreedyDecoderSingle(self): graph = build_graph(self.nodes_attributes, [ ('logits', 'decoder', { 'out': 0, 'in': 0 }), ('seq_len', 'decoder', { 'out': 0, 'in': 1 }), ('decoder', 'last', { 'out': 0, 'in': 0 }), ('decoder', 'last_1', { 'out': 1, 'in': 0 }), ], nodes_with_edges_only=True) graph.stage = 'front' CTCGreedyDecoderSingleReplacement().find_and_replace_pattern(graph) graph_ref = build_graph(self.nodes_attributes, [ ('logits', 'transpose', { 'out': 0, 'in': 0 }), ('order_arr', 'transpose', { 'out': 0, 'in': 1 }), ('transpose', 'new_decoder', { 'out': 0, 'in': 0 }), ('seq_len', 'new_decoder', { 'out': 0, 'in': 1 }), ('new_decoder', 'last', { 'out': 0, 'in': 0 }), ('new_decoder', 'last_1', { 'out': 1, 'in': 0 }), ], nodes_with_edges_only=True) (flag, resp) = compare_graphs(graph, graph_ref, 'last', check_op_attrs=True) self.assertTrue(flag, resp) def test_CTCGreedyDecoderSingle_negative(self): edges = [ ('logits', 'decoder', { 'out': 0, 'in': 0 }), ('seq_len', 'decoder', { 'out': 0, 'in': 1 }), ('decoder', 'sparse_to_dense', { 'out': 0, 'in': 0 }), ('decoder', 'cast', { 'out': 1, 'in': 0 }), ('cast', 'sparse_to_dense', { 'out': 0 }), ('sparse_to_dense', 'last', { 'out': 0, 'in': 0 }), ] graph = build_graph(self.nodes_attributes, edges, nodes_with_edges_only=True) graph.stage = 'front' CTCGreedyDecoderSingleReplacement().find_and_replace_pattern(graph) graph_ref = build_graph(self.nodes_attributes, edges, nodes_with_edges_only=True) (flag, resp) = compare_graphs(graph, graph_ref, 'last', check_op_attrs=True) self.assertTrue(flag, resp) def test_CTCGreedyDecoder_no_consequent_transforms(self): graph = build_graph(self.nodes_attributes, [ ('logits', 'decoder', { 'out': 0, 'in': 0 }), ('seq_len', 'decoder', { 'out': 0, 'in': 1 }), ('decoder', 'sparse_to_dense', { 'out': 0, 'in': 0 }), ('decoder', 'sparse_to_dense', { 'out': 2, 'in': 1 }), ('decoder', 'cast', { 'out': 1, 'in': 0 }), ('cast', 'sparse_to_dense', { 'out': 0 }), ('sparse_to_dense', 'last', { 'out': 0, 'in': 0 }), ], nodes_with_edges_only=True) graph.stage = 'front' CTCGreedyDecoderWithSparseToDenseShapeReplacement( ).find_and_replace_pattern(graph) CTCGreedyDecoderSingleReplacement().find_and_replace_pattern(graph) graph_ref = build_graph(self.nodes_attributes, [ ('logits', 'transpose', { 'out': 0, 'in': 0 }), ('order_arr', 'transpose', { 'out': 0, 'in': 1 }), ('transpose', 'new_decoder', { 'out': 0, 'in': 0 }), ('seq_len', 'new_decoder', { 'out': 0, 'in': 1 }), ('new_decoder', 'last', { 'out': 0, 'in': 0 }), ], nodes_with_edges_only=True) (flag, resp) = compare_graphs(graph, graph_ref, 'last', check_op_attrs=True) self.assertTrue(flag, resp)
'op': 'Result' }, # new Pad layer and inputs 'pad': { 'type': 'Pad', 'kind': 'op', 'op': 'Pad', 'mode': 'constant' }, 'convert_like': { 'type': 'ConvertLike', 'kind': 'op', 'op': 'ConvertLike' }, **const('pad_begin', int64_array([1, 3, 5])), **const('pad_end', int64_array([2, 4, 6])), **const('pad_fill', np.array(0.75)), } class AttributedPadToPadTest(unittest.TestCase): def test_mode_constant(self): graph = build_graph(nodes_attributes, [ ('placeholder', 'attr_pad', { 'in': 0, 'out': 0 }), ('attr_pad', 'result', { 'in': 0, 'out': 0
nodes_attributes = { 'placeholder': { 'shape': None, 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter' }, 'tfpad': { 'type': None, 'kind': 'op', 'op': 'TFPad', 'mode': 'constant', 'name': 'tfpad_name' }, **const('paddings', int64_array([1, 2, 3, 4, 5, 6]).reshape([3, 2])), **const('fill', float_array(5.75)), 'result': { 'type': 'Result', 'value': None, 'kind': 'op', 'op': 'Result' }, # new Pad layer and sub-graph 'pad': { 'type': 'Pad', 'kind': 'op', 'op': 'Pad', 'mode': 'constant' },
def test_per_sample_weights(self): nodes = { **const('weights_inp', np.random.randn(100, 2)), **regular_op('indices_inp', {'type': 'Parameter'}), **regular_op('offsets_inp', {'type': 'Parameter'}), **regular_op('per_sample_weights', {'type': 'Parameter'}), **regular_op( 'aten', { 'type': None, 'kind': 'op', 'op': 'ATen', 'operator': 'embedding_bag', 'mode': 0, 'name': 'my_aten' }), **regular_op( 'emb_bag', { 'type': 'EmbeddingBagOffsetsSum', 'kind': 'op', 'op': 'EmbeddingBagOffsetsSum' }), **regular_op('WeightsRank', { 'type': None, 'kind': 'op', 'op': 'Rank' }), **regular_op('WeightsRank/axis', { 'type': 'Add', 'kind': 'op', 'op': 'Add' }), **regular_op('gather1', { 'type': 'Gather', 'kind': 'op', 'op': 'Gather' }), **regular_op('gather2', { 'type': 'Gather', 'kind': 'op', 'op': 'Gather' }), **regular_op('WeightsShape', { 'type': 'ShapeOf', 'kind': 'op', 'op': 'ShapeOf' }), **regular_op('Broadcast', { 'type': 'Broadcast', 'kind': 'op', 'op': 'Broadcast' }), **regular_op('Unsqueeze', { 'type': 'Unsqueeze', 'kind': 'op', 'op': 'Unsqueeze' }), **const('WeightsShape/Axis', int64_array(0)), **const('zero1', int64_array(0)), **const('zero2', int64_array(0)), **const('Unsqueeze/value', int64_array(0)), **const('Broadcast/value', int64_array(0)), **const('neg', int64_array(-1)), **regular_op('Concat', { 'type': 'Concat', 'kind': 'op', 'op': 'Concat' }), **result('result'), } edges = [ ('weights_inp', 'aten'), ('indices_inp', 'aten'), ('offsets_inp', 'aten'), ('per_sample_weights', 'aten'), ('aten', 'result'), ] graph = build_graph(nodes, edges, nodes_with_edges_only=True) graph.graph['layout'] = 'NCHW' graph.stage = 'front' edges_ref = [ ('weights_inp', 'Concat', { 'in': 0, 'out': 0 }), ('weights_inp', 'WeightsShape', { 'in': 0, 'out': 0 }), ('weights_inp', 'WeightsRank', { 'in': 0, 'out': 0 }), ('WeightsRank', 'WeightsRank/axis'), ('neg', 'WeightsRank/axis'), ('WeightsShape', 'gather1', { 'in': 0, 'out': 0 }), ('WeightsRank/axis', 'gather1'), ('WeightsShape/Axis', 'gather1'), ('WeightsShape', 'gather2', { 'in': 0, 'out': 0 }), ('zero1', 'gather2'), ('zero2', 'gather2'), ('Broadcast/value', 'Broadcast'), ('gather1', 'Broadcast'), ('Broadcast', 'Unsqueeze'), ('Unsqueeze/value', 'Unsqueeze'), ('Unsqueeze', 'Concat'), ('Concat', 'emb_bag'), ('indices_inp', 'emb_bag'), ('offsets_inp', 'emb_bag'), ('gather2', 'emb_bag'), ('per_sample_weights', 'emb_bag'), ('emb_bag', 'result'), ] graph_ref = build_graph(nodes, edges_ref, nodes_with_edges_only=True) AtenToEmbeddingBag().find_and_replace_pattern(graph) (flag, resp) = compare_graphs(graph, graph_ref, 'result') self.assertTrue(flag, resp)
class HSigmoidWithReluMulTest(unittest.TestCase): nodes = { **regular_op('input', {'type': 'Parameter'}), **regular_op('add', {'op': 'Add'}), **regular_op('relu', {'op': 'ReLU'}), **regular_op('min', {'op': 'Minimum'}), **regular_op('mul', { 'op': 'Mul', 'name': 'final_mul' }), **const('add_const', float_array([3.0])), **const('min_const', float_array([6.0])), **const('mul_const', float_array([1.0 / 6.0])), **result('result'), } edges = [('input', 'add', { 'in': 0, 'out': 0 }), ('add_const', 'add', { 'in': 1, 'out': 0 }), ('add', 'relu', { 'in': 0, 'out': 0 }), ('relu', 'min', { 'in': 0, 'out': 0 }), ('min_const', 'min', { 'in': 1, 'out': 0 }), ('min', 'mul', { 'in': 0, 'out': 0 }), ('mul_const', 'mul', { 'in': 1, 'out': 0 }), ('mul', 'result', { 'in': 0, 'out': 0 })] def test_hsigmoid_with_relu_mul(self): graph = build_graph_with_edge_attrs(self.nodes, self.edges, {}) graph_ref = build_graph(ref_nodes, ref_edges) graph.stage = 'front' HSigmoidWithReluMul().find_and_replace_pattern(graph) (flag, resp) = compare_graphs(graph, graph_ref, 'result') self.assertTrue(flag, resp) self.assertTrue( len(graph.get_op_nodes(name='final_mul')) == 1 and graph.get_op_nodes(name='final_mul')[0].op == 'HSigmoid') self.assertTrue( graph.get_op_nodes( name='final_mul')[0].out_nodes()[0].node == 'result') def test_hsigmoid_with_relu_mul_wrong_constant(self): graph = build_graph_with_edge_attrs( self.nodes, self.edges, {'add_const': { 'value': float_array([0.00001]) }}) graph_ref = graph.copy() graph.stage = 'front' HSigmoidWithReluMul().find_and_replace_pattern(graph) (flag, resp) = compare_graphs(graph, graph_ref, 'result') self.assertTrue(flag, resp) def test_hsigmoid_with_relu_mul_different_tensors(self): graph = build_graph_with_edge_attrs( { **regular_op('input', {'type': 'Parameter'}), **regular_op('input_2', {'type': 'Parameter'}), **regular_op('add', {'op': 'Add'}), **regular_op('max', {'op': 'Maximum'}), **regular_op('min', {'op': 'Minimum'}), **regular_op('mul', {'op': 'Mul'}), **regular_op('mul_2', { 'op': 'Mul', 'name': 'final_mul' }), **const('const_0', float_array([0.0])), **const('const_3', float_array([3.0])), **const('const_6', float_array([6.0])), **const('const_1_6', float_array([1.0 / 6.0])), **result('result'), }, [('input_2', 'mul', { 'in': 1, 'out': 0 }), ('input', 'add', { 'in': 0, 'out': 0 }), ('const_3', 'add', { 'in': 1, 'out': 0 }), ('add', 'max', { 'in': 0, 'out': 0 }), ('const_0', 'max', { 'in': 1, 'out': 0 }), ('max', 'min', { 'in': 0, 'out': 0 }), ('const_6', 'min', { 'in': 1, 'out': 0 }), ('min', 'mul', { 'in': 0, 'out': 0 }), ('mul', 'mul_2', { 'in': 0, 'out': 0 }), ('const_1_6', 'mul_2', { 'in': 1, 'out': 0 }), ('mul_2', 'result', { 'in': 0, 'out': 0 })]) graph_ref = graph.copy() graph.stage = 'front' HSigmoidWithReluMul().find_and_replace_pattern(graph) (flag, resp) = compare_graphs(graph, graph_ref, 'result') self.assertTrue(flag, resp)
import unittest import numpy as np from openvino.tools.mo.front.onnx.pad_converter import ONNXPadToPad from openvino.tools.mo.utils.ir_engine.compare_graphs import compare_graphs from unit_tests.utils.graph import build_graph, const nodes_attributes = { 'placeholder': { 'shape': None, 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter' }, **const('pads', np.array([1, 2, 3, 4], dtype=np.int64)), **const('value', np.array(0.5, dtype=np.float32)), 'onnx_pad': { 'type': None, 'kind': 'op', 'op': 'ONNXPad', 'name': 'my_pad', 'mode': 'constant' }, 'result': { 'type': 'Result', 'value': None, 'kind': 'op', 'op': 'Result' }, 'pad': {
import unittest import numpy as np from openvino.tools.mo.front.tf.TFSliceToSlice import TFSliceToSliceReplacer from openvino.tools.mo.utils.ir_engine.compare_graphs import compare_graphs from unit_tests.utils.graph import build_graph, regular_op_with_empty_data, result, const, connect_front nodes = { **regular_op_with_empty_data('input', {'type': 'Parameter'}), **regular_op_with_empty_data('tfslice', { 'op': 'TFSlice', 'type': None }), **const('begin', np.array(0)), **const('size', np.array([-1])), **regular_op_with_empty_data('john_doe', { 'op': 'Sum', 'type': None }), **result(), # nodes after replacement **const('minus_one', np.array(-1)), **regular_op_with_empty_data('shapeof', { 'op': 'ShapeOf', 'type': 'ShapeOf' }), **regular_op_with_empty_data('end_const', { 'op': 'Add',
'attr_split': { 'type': None, 'kind': 'op', 'op': 'AttributedSplit', 'axis': 0, 'num_splits': 2, 'squeeze_axis': True }, 'split': { 'type': 'Split', 'kind': 'op', 'op': 'Split', 'num_splits': 2, 'squeeze_axis': True }, **const('split_axis', int64_array(0)), 'concat': { 'type': 'Concat', 'kind': 'op', 'op': 'Concat', 'axis': 0 }, 'result': { 'type': 'Result', 'value': None, 'kind': 'op', 'op': 'Result' }, 'squeeze1': { 'type': 'Squeeze', 'kind': 'op',