def __init__(self): self.sequence_with_zero_padding = GraphSequence([ ConverterSequenceNode('root', ['Pad', 'PadV2']), ConverterSequenceNode('paddings', ['Const']), NonConsumableConverterSequenceNode('input', ['?']), ]) self.sequence_with_zero_padding.set_inputs('root', ['input', 'paddings']) self.sequence_with_zero_padding.set_outputs(['root']) self.sequence_with_const_padding = GraphSequence([ ConverterSequenceNode('root', ['Pad', 'PadV2']), ConverterSequenceNode('paddings', ['Const']), ConverterSequenceNode('const_values', ['Const']), NonConsumableConverterSequenceNode('input', ['?']), ]) self.sequence_with_const_padding.set_inputs( 'root', ['input', 'paddings', 'const_values']) self.sequence_with_const_padding.set_outputs(['root']) self.sequence_with_reflect_padding = GraphSequence([ ConverterSequenceNode('mirror_pad', ['MirrorPad']), ConverterSequenceNode('paddings', ['Const']), NonConsumableConverterSequenceNode('input', ['?']), ]) self.sequence_with_reflect_padding.set_inputs('mirror_pad', ['input', 'paddings']) self.sequence_with_reflect_padding.set_outputs(['mirror_pad']) self.sequences = [ self.sequence_with_zero_padding, self.sequence_with_const_padding, self.sequence_with_reflect_padding ]
def __init__(self): self.sequence_with_explicit_order = GraphSequence([ ConverterSequenceNode('root', ['Transpose']), ConverterSequenceNode('order', ['Const']), NonConsumableConverterSequenceNode('input', ['?']), ]) self.sequence_with_explicit_order.set_inputs('root', ['input', 'order']) self.sequence_with_explicit_order.set_outputs(['root']) self.sequence_with_implicit_order = GraphSequence([ ConverterSequenceNode('root', ['Transpose']), ConverterSequenceNode('order', ['Sub']), ConverterSequenceNode('a', ['Sub']), ConverterSequenceNode('b', ['Const']), ConverterSequenceNode('c', ['Range']), ConverterSequenceNode('d', ['Const']), ConverterSequenceNode('e', ['Const']), ConverterSequenceNode('f', ['Rank']), NonConsumableConverterSequenceNode('input', ['?']) ]) self.sequence_with_implicit_order.set_inputs('root', ['input', 'order']) self.sequence_with_implicit_order.set_inputs('order', ['a', 'c']) self.sequence_with_implicit_order.set_inputs('a', ['b', 'f']) self.sequence_with_implicit_order.set_inputs('c', ['d', 'e', 'f']) self.sequence_with_implicit_order.set_inputs('f', ['input']) self.sequence_with_implicit_order.set_outputs(['root']) self.sequences = [ self.sequence_with_explicit_order, self.sequence_with_implicit_order ]
def __init__(self): sequence_prelu = GraphSequence([ ConverterSequenceNode('a', ['Relu']), ConverterSequenceNode('b', ['Abs']), ConverterSequenceNode('c', ['Sub']), ConverterSequenceNode('d', ['Mul']), ConverterSequenceNode('e', ['Mul']), ConverterSequenceNode('f', ['Add']), # output ConverterSequenceNode('unknown', ['?']), ConverterSequenceNode('alphas', ['?']), NonConsumableConverterSequenceNode('inputs', ['?']) ]) sequence_prelu.set_inputs('a', ['inputs']) sequence_prelu.set_inputs('b', ['inputs']) sequence_prelu.set_inputs('c', ['inputs', 'b']) sequence_prelu.set_inputs('d', ['alphas', 'c']) sequence_prelu.set_inputs('e', ['d', 'unknown']) sequence_prelu.set_inputs('f', ['a', 'e']) sequence_prelu.set_outputs(['f']) sequence_prelu_negative_alpha = GraphSequence([ ConverterSequenceNode('a', ['Relu']), ConverterSequenceNode('b', ['Neg']), ConverterSequenceNode('c', ['Neg']), ConverterSequenceNode('d', ['Relu']), ConverterSequenceNode('e', ['Mul']), ConverterSequenceNode('f', ['Add']), # output ConverterSequenceNode('alphas', ['?']), NonConsumableConverterSequenceNode('inputs', ['?']) ]) sequence_prelu_negative_alpha.set_inputs('a', ['inputs']) sequence_prelu_negative_alpha.set_inputs('b', ['inputs']) sequence_prelu_negative_alpha.set_inputs('c', ['alphas']) sequence_prelu_negative_alpha.set_inputs('d', ['b']) sequence_prelu_negative_alpha.set_inputs('e', ['d', 'c']) sequence_prelu_negative_alpha.set_inputs('f', ['a', 'e']) sequence_prelu_negative_alpha.set_outputs(['f']) sequence_prelu_negative_relu = GraphSequence([ ConverterSequenceNode('relu_pos', ['Relu']), ConverterSequenceNode('neg_1', ['Neg']), ConverterSequenceNode('neg_2', ['Neg']), ConverterSequenceNode('relu_neg', ['Relu']), ConverterSequenceNode('mul', ['Mul']), ConverterSequenceNode('f', ['Add']), # output ConverterSequenceNode('alphas', ['?']), NonConsumableConverterSequenceNode('inputs', ['?']) ]) sequence_prelu_negative_relu.set_inputs('relu_pos', ['inputs']) sequence_prelu_negative_relu.set_inputs('neg_1', ['inputs']) sequence_prelu_negative_relu.set_inputs('relu_neg', ['neg_1']) sequence_prelu_negative_relu.set_inputs('neg_2', ['relu_neg']) sequence_prelu_negative_relu.set_inputs('mul', ['neg_2', 'alphas']) sequence_prelu_negative_relu.set_inputs('f', ['relu_pos', 'mul']) sequence_prelu_negative_relu.set_outputs(['f']) self.sequences = [ sequence_prelu, sequence_prelu_negative_alpha, sequence_prelu_negative_relu ]
def __init__(self): sequence = GraphSequence([ ConverterSequenceNode('matmul_op', ['MatMul']), ConverterSequenceNode('bias_op', ['BiasAdd', 'Add']), # output NonConsumableConverterSequenceNode('biases', ['Identity', 'Const']), NonConsumableConverterSequenceNode('weights', ['Identity', 'Const']), NonConsumableConverterSequenceNode('inputs', ['?']) ]) sequence.set_inputs('matmul_op', ['inputs', 'weights']) sequence.set_inputs('bias_op', ['matmul_op', 'biases']) sequence.set_outputs(['bias_op']) sequence_without_bias = GraphSequence([ ConverterSequenceNode('matmul_op', ['MatMul']), NonConsumableConverterSequenceNode('weights', ['Identity', 'Const']), NonConsumableConverterSequenceNode('inputs', ['?']) ]) sequence_without_bias.set_inputs('matmul_op', ['inputs', 'weights']) sequence_without_bias.set_outputs(['matmul_op']) self.sequences = [sequence_without_bias, sequence]
def __init__(self): self.sequence = GraphSequence([ ConverterSequenceNode('root', ['Slice']), NonConsumableConverterSequenceNode('input', ['?']), NonConsumableConverterSequenceNode('offsets', ['?']), NonConsumableConverterSequenceNode('size', ['?']), ]) self.sequence.set_inputs('root', ['input', 'offsets', 'size']) self.sequence.set_outputs(['root'])
def __init__(self): super(GroupedConvolutionLayerResolver, self).__init__() # grouped convolution with split tree_output_node = ConverterSequenceNode('conv_op', ['Conv2D']) self.sequence = GraphSequence([ ConverterSequenceNode('a', ['Split']), ConverterSequenceNode('b', ['Split']), ConverterRepeatableSequenceTreeNode('repeatable_graph', tree_output_node, tree_output_node), ConverterSequenceNode('concat_op', ['Concat']), ConverterSequenceNode('weights', ['Identity', 'Const']), NonConsumableConverterSequenceNode('inputs', ['?']), NonConsumableConverterSequenceNode('concat_dim', ['Const']), NonConsumableConverterSequenceNode('split_dim1', ['Const']), ConverterSequenceNode('split_dim2', ['Const']) ]) self.sequence.set_inputs('a', ['inputs', 'split_dim1']) self.sequence.set_inputs('b', ['weights', 'split_dim2']) self.sequence.set_inputs('repeatable_graph', ['a', 'b']) self.sequence.set_inputs('concat_op', ['repeatable_graph', 'concat_dim']) self.sequence.set_outputs(['concat_op']) # grouped convolution with strided slice repeatable_sequence = GraphSequence([ ConverterSequenceNode('ss', ['StridedSlice']), ConverterSequenceNode('ss_begin', ['Const']), ConverterSequenceNode('ss_end', ['Const']), ConverterSequenceNode('ss_strides', ['Const']), ConverterSequenceNode('conv', ['Conv2D']), ConverterSequenceNode('bias', ['BiasAdd']), ConverterSequenceNode('weights', ['Identity', 'Const']), ConverterSequenceNode('biases', ['Identity', 'Const']) ]) repeatable_sequence.set_inputs('ss', ['ss_begin', 'ss_end', 'ss_strides']) repeatable_sequence.set_inputs('conv', ['ss', 'weights']) repeatable_sequence.set_inputs('bias', ['biases', 'conv']) repeatable_sequence.set_outputs(['bias']) self.sequence_with_strided_slice = GraphSequence([ ConverterRepeatableSequenceTreeNode( 'repeatable_graph', tree_output_node=repeatable_sequence['bias'], tree_input_node=repeatable_sequence['ss']), ConverterSequenceNode('concat', ['Concat', 'ConcatV2']), ConverterSequenceNode('axis', ['Const']), NonConsumableConverterSequenceNode('input', ['?']) ]) self.sequence_with_strided_slice.set_inputs('repeatable_graph', ['input']) self.sequence_with_strided_slice.set_inputs( 'concat', ['repeatable_graph', 'axis']) self.sequence_with_strided_slice.set_outputs(['concat'])
def __init__(self): sequence_extract_glimpse = GraphSequence([ NonConsumableConverterSequenceNode('input', ['?']), NonConsumableConverterSequenceNode('offsets', ['?']), ConverterSequenceNode('size', ['Const']), ConverterSequenceNode('extract_glimpse', ['ExtractGlimpse']) ]) sequence_extract_glimpse.set_inputs('extract_glimpse', ['input', 'size', 'offsets']) sequence_extract_glimpse.set_outputs(['extract_glimpse']) self.sequences = [sequence_extract_glimpse]
def __init__(self): sequence_crop_and_resize = GraphSequence([ NonConsumableConverterSequenceNode('input', ['?']), NonConsumableConverterSequenceNode('boxes', ['?']), NonConsumableConverterSequenceNode('box_ind', ['?']), NonConsumableConverterSequenceNode('crop_size', ['?']), ConverterSequenceNode('crop_and_resize', ['CropAndResize']), ]) sequence_crop_and_resize.set_inputs('crop_and_resize', ['input', 'boxes', 'box_ind', 'crop_size']) sequence_crop_and_resize.set_outputs(['crop_and_resize']) self.sequences = [sequence_crop_and_resize]
def __init__(self): sequence_resize = GraphSequence([ConverterSequenceNode('root', ['ResizeBilinear'])]) sequence_resize.set_outputs(['root']) sequence_shape_stridedslice_resize = GraphSequence([ NonConsumableConverterSequenceNode('input', ['?']), ConverterSequenceNode('shape', ['Shape']), ConverterSequenceNode('stridedSlice', ['StridedSlice']), ConverterSequenceNode('mul', ['Mul']), ConverterSequenceNode('const_stridedSlice_1', ['?']), ConverterSequenceNode('const_stridedSlice_2', ['?']), ConverterSequenceNode('const_stridedSlice_3', ['?']), ConverterSequenceNode('mul_const', ['?']), ConverterSequenceNode('root', ['ResizeBilinear'])]) sequence_shape_stridedslice_resize.set_inputs('shape', ['input']) sequence_shape_stridedslice_resize.set_inputs('stridedSlice', ['shape', 'const_stridedSlice_1', 'const_stridedSlice_2', 'const_stridedSlice_3']) sequence_shape_stridedslice_resize.set_inputs('mul', ['stridedSlice', 'mul_const']) sequence_shape_stridedslice_resize.set_inputs('root', ['mul', 'input']) sequence_shape_stridedslice_resize.set_outputs(['root']) self.sequences = [sequence_resize, sequence_shape_stridedslice_resize]
def __init__(self): sequence_two_dim_softmax = GraphSequence( [ConverterSequenceNode('root', ['SoftMax'])]) sequence_two_dim_softmax.set_outputs(['root']) sequence_multi_dim_softmax = GraphSequence([ ConverterSequenceNode('max', ['Max']), ConverterSequenceNode('max_reduction_indicies', ['Const']), ConverterSequenceNode('sub', ['Sub']), ConverterSequenceNode('exp', ['Exp']), ConverterSequenceNode('sum', ['Sum']), ConverterSequenceNode('sum_reduction_indicies', ['Const']), ConverterSequenceNode('root', ['RealDiv']), NonConsumableConverterSequenceNode('input', ['?']) ]) sequence_multi_dim_softmax.set_inputs( 'max', ['input', 'max_reduction_indicies']) sequence_multi_dim_softmax.set_inputs('sub', ['input', 'max']) sequence_multi_dim_softmax.set_inputs('exp', ['sub']) sequence_multi_dim_softmax.set_inputs( 'sum', ['exp', 'sum_reduction_indicies']) sequence_multi_dim_softmax.set_inputs('root', ['exp', 'sum']) sequence_multi_dim_softmax.set_outputs(['root']) self.sequences = [sequence_two_dim_softmax, sequence_multi_dim_softmax]
def __init__(self): self.sequence = GraphSequence([ ConverterSequenceNode('root', ['ArgMax']), ConverterSequenceNode('axis', ['Const']), NonConsumableConverterSequenceNode('input', ['?']), ]) self.sequence.set_inputs('root', ['input', 'axis']) self.sequence.set_outputs(['root'])
def __init__(self): self.sequence = GraphSequence([ ConverterSequenceNode('root', ['FakeQuantWithMinMaxVars']), ConverterSequenceNode('min', ['?']), ConverterSequenceNode('max', ['?']), NonConsumableConverterSequenceNode('input', ['?']) ]) self.sequence.set_inputs('root', ['input', 'min', 'max']) self.sequence.set_outputs(['root'])
def __init__(self): self.sequence = GraphSequence([ ConverterSequenceNode('root', ['StridedSlice']), ConverterSequenceNode('begin', ['Const']), ConverterSequenceNode('end', ['Const']), ConverterSequenceNode('strides', ['Const']), NonConsumableConverterSequenceNode('input', ['?']), ]) self.sequence.set_inputs('root', ['input', 'begin', 'end', 'strides']) self.sequence.set_outputs(['root'])
def __init__(self): sequence_scalar_pow = GraphSequence([ NonConsumableConverterSequenceNode('input', ['?']), ConverterSequenceNode('pow', ['Pow']), ConverterSequenceNode('const', ['Const']) ]) sequence_scalar_pow.set_inputs('pow', ['input', 'const']) sequence_scalar_pow.set_outputs(['pow']) self.sequences = [sequence_scalar_pow]
def __init__(self): self.sequence = GraphSequence([ NonConsumableConverterSequenceNode('inputs', ['?']), ConverterSequenceNode('a', ['Mul']), ConverterSequenceNode('b', ['Add']), ConverterSequenceNode('weights', ['Const', 'Identity']), ConverterSequenceNode('biases', ['Const', 'Identity']) ]) self.sequence.set_inputs('a', ['inputs', 'weights']) self.sequence.set_inputs('b', ['a', 'biases']) self.sequence.set_outputs(['b'])
def __init__(self): sequence_1 = GraphSequence([ ConverterSequenceNode('gather', ['GatherV2']), NonConsumableConverterSequenceNode('params', ['?']), NonConsumableConverterSequenceNode('axis', ['?']), NonConsumableConverterSequenceNode('indices', ['Placeholder']) ]) sequence_1.set_inputs('gather', ['params', 'axis', 'indices']) sequence_1.set_outputs(['gather']) # Filter seqs 2 sequence_2 = GraphSequence([ ConverterSequenceNode('gather', ['Gather']), NonConsumableConverterSequenceNode('params', ['?']), NonConsumableConverterSequenceNode('indices', ['Placeholder']) ]) sequence_2.set_inputs('gather', ['params', 'indices']) sequence_2.set_outputs(['gather']) self.sequences = [sequence_1, sequence_2]
def __init__(self, layer_type, op_type, descriptor_class): super(EltWiseUnaryLayerResolver, self).__init__() self._layer_type = layer_type self._op_type = op_type self._descriptor_class = descriptor_class self.sequence = GraphSequence([ ConverterSequenceNode('root', [self._op_type]), NonConsumableConverterSequenceNode('input1', ['?']), ]) self.sequence.set_inputs('root', ['input1']) self.sequence.set_outputs(['root'])
def __init__(self, layer_type, op_type, descriptor_class): super(ReductionLayerResolver, self).__init__() self._layer_type = layer_type self._op_type = op_type self._descriptor_class = descriptor_class self.sequence = GraphSequence([ ConverterSequenceNode('root', [self._op_type]), ConverterSequenceNode('reduction_indices', ['Const']), NonConsumableConverterSequenceNode('input', ['?']), ]) self.sequence.set_inputs('root', ['input', 'reduction_indices']) self.sequence.set_outputs(['root'])
def __init__(self): super(DepthwiseConvolutionLayerResolver, self).__init__() self.graph_sequence_with_bias = GraphSequence([ ConverterSequenceNode('conv', ['DepthwiseConv2dNative']), ConverterSequenceNode('bias', ['BiasAdd', 'Add']), NonConsumableConverterSequenceNode('other', ['?']) ]) self.graph_sequence_with_bias.set_inputs('bias', ['conv', 'other']) self.graph_sequence_with_bias.set_outputs(['bias']) self.graph_sequence = GraphSequence( [ConverterSequenceNode('conv', ['DepthwiseConv2dNative'])]) self.graph_sequence.set_outputs(['conv'])
def __init__(self): self.sequence = GraphSequence([ ConverterSequenceNode('reshape_out', ['Reshape']), ConverterSequenceNode('transpose', ['Transpose']), ConverterSequenceNode('reshape_in', ['Reshape']), ConverterSequenceNode('shape_in', ['Const']), ConverterSequenceNode('order', ['Const']), ConverterSequenceNode('shape_out', ['Const']), NonConsumableConverterSequenceNode('input', ['?']), ]) self.sequence.set_inputs('reshape_out', ['shape_out', 'transpose']) self.sequence.set_inputs('transpose', ['order', 'reshape_in']) self.sequence.set_inputs('reshape_in', ['shape_in', 'input']) self.sequence.set_outputs(['reshape_out'])
def __init__(self): super(MomentsLayerResolver, self).__init__() # Graph sequence where keep_dims is False and dims of 1 are stripped (default) sequence = GraphSequence([ ConverterSequenceNode('moments/mean', ['Mean']), ConverterSequenceNode('moments/StopGradient', ['StopGradient']), ConverterSequenceNode('moments/SquaredDifference', ['SquaredDifference']), ConverterSequenceNode('moments/variance', ['Mean']), ConverterSequenceNode('moments/squeeze_mean', ['Squeeze']), ConverterSequenceNode('moments/squeeze_variance', ['Squeeze']), NonConsumableConverterSequenceNode('input', ['?']), NonConsumableConverterSequenceNode('mean_reduction_indices', ['?']), NonConsumableConverterSequenceNode('variance_reduction_indices', ['?']), ]) sequence.set_inputs('moments/mean', ['input', 'mean_reduction_indices']) sequence.set_inputs('moments/StopGradient', ['moments/mean']) sequence.set_inputs('moments/SquaredDifference', ['input', 'moments/StopGradient']) sequence.set_inputs( 'moments/variance', ['moments/SquaredDifference', 'variance_reduction_indices']) sequence.set_inputs('moments/squeeze_mean', ['moments/mean']) sequence.set_inputs('moments/squeeze_variance', ['moments/variance']) sequence.set_outputs( ['moments/squeeze_mean', 'moments/squeeze_variance']) # Graph sequence where keep_dims is True and input dimensions are maintained sequence_keep_dims = GraphSequence([ ConverterSequenceNode('moments/mean', ['Mean']), ConverterSequenceNode('moments/StopGradient', ['StopGradient']), ConverterSequenceNode('moments/SquaredDifference', ['SquaredDifference']), ConverterSequenceNode('moments/variance', ['Mean']), NonConsumableConverterSequenceNode('input', ['?']), NonConsumableConverterSequenceNode('variance_reduction_indices', ['?']), NonConsumableConverterSequenceNode('mean_reduction_indices', ['?']), ]) sequence_keep_dims.set_inputs('moments/mean', ['input', 'mean_reduction_indices']) sequence_keep_dims.set_inputs('moments/StopGradient', ['moments/mean']) sequence_keep_dims.set_inputs('moments/SquaredDifference', ['input', 'moments/StopGradient']) sequence_keep_dims.set_inputs( 'moments/variance', ['moments/SquaredDifference', 'variance_reduction_indices']) sequence_keep_dims.set_outputs(['moments/mean', 'moments/variance']) self.sequences = [sequence, sequence_keep_dims]
def __init__(self): sequence_keras = GraphSequence([ NonConsumableConverterSequenceNode('input', ['?']), ConverterSequenceNode('root', ['Relu']), ConverterSequenceNode('min', ['Minimum']), ConverterSequenceNode('min_cast', ['Cast']), ConverterSequenceNode('min_const', ['Const']), ConverterSequenceNode('max', ['Maximum']), ConverterSequenceNode('max_const', ['Const']) ]) sequence_keras.set_inputs('root', ['input']) sequence_keras.set_inputs('min_cast', ['min_const']) sequence_keras.set_inputs('min', ['root', 'min_cast']) sequence_keras.set_inputs('max', ['min', 'max_const']) sequence_keras.set_outputs(['max']) self.sequences = [sequence_keras]
def __init__(self, layer_type, op_type, descriptor_class): super(EltWiseLayerResolver, self).__init__() self._layer_type = layer_type self._op_type = op_type self._descriptor_class = descriptor_class self.sequence = GraphSequence([ ConverterSequenceNode('root', [self._op_type]), NonConsumableConverterSequenceNode('input1', ['?']), NonConsumableConverterSequenceNode('input2', ['?']) ]) self.sequence.set_inputs('root', ['input1', 'input2']) self.sequence.set_outputs(['root']) self.sequence_with_identity = GraphSequence([ ConverterSequenceNode('root', [self._op_type]), ConverterSequenceNode('identity', ['Identity']), NonConsumableConverterSequenceNode('input1', ['?']), NonConsumableConverterSequenceNode('input2', ['?']) ]) self.sequence_with_identity.set_inputs('identity', ['root']) self.sequence_with_identity.set_inputs('root', ['input1', 'input2']) self.sequence_with_identity.set_outputs(['identity']) self.sequence_with_const_input = GraphSequence([ ConverterSequenceNode('root', [self._op_type]), NonConsumableConverterSequenceNode('const', ['Const', 'Identity']), NonConsumableConverterSequenceNode('other', ['?']) ]) self.sequence_with_const_input.set_inputs('root', ['const', 'other']) self.sequence_with_const_input.set_outputs(['root']) self.sequence_with_const_input_and_identity = GraphSequence([ ConverterSequenceNode('root', [self._op_type]), ConverterSequenceNode('identity', ['Identity']), NonConsumableConverterSequenceNode('const', ['Const', 'Identity']), NonConsumableConverterSequenceNode('other', ['?']) ]) self.sequence_with_const_input_and_identity.set_inputs( 'root', ['const', 'other']) self.sequence_with_const_input_and_identity.set_inputs( 'identity', ['root']) self.sequence_with_const_input_and_identity.set_outputs(['identity'])
def __init__(self): # Graph topology of tf.math.l2_normalize self.sequence = GraphSequence([ NonConsumableConverterSequenceNode('input', ['?']), ConverterSequenceNode('a', ['Square']), ConverterSequenceNode('weights', ['Const', 'Identity']), ConverterSequenceNode('b', ['Sum']), ConverterSequenceNode('epsilon', ['Const', 'Identity']), ConverterSequenceNode('c', ['Maximum']), ConverterSequenceNode('d', ['Rsqrt']), ConverterSequenceNode('e', ['Mul']) ]) self.sequence.set_inputs('a', ['input']) self.sequence.set_inputs('b', ['a', 'weights']) self.sequence.set_inputs('c', ['b', 'epsilon']) self.sequence.set_inputs('d', ['c']) self.sequence.set_inputs('e', ['d', 'input']) self.sequence.set_outputs(['e'])
def __init__(self): super(DilatedConvolutionLayerResolver, self).__init__() self.graph_sequence = GraphSequence([ ConverterSequenceNode('space_to_batch', ['SpaceToBatchND']), NonConsumableConverterSequenceNode('inputs', ['?']), ConverterSequenceNode('dilation_sizes', ['?']), ConverterSequenceNode('paddings', ['?']), ConverterSequenceNode('conv_op', ['Conv2D']), ConverterSequenceNode('kernel', ['?']), ConverterSequenceNode('batch_to_space', ['BatchToSpaceND']), ConverterSequenceNode('block_shape_out', ['?']), ConverterSequenceNode('crops', ['?']) ]) self.graph_sequence.set_inputs( 'space_to_batch', ['inputs', 'dilation_sizes', 'paddings']) self.graph_sequence.set_inputs('conv_op', ['space_to_batch', 'kernel']) self.graph_sequence.set_inputs('batch_to_space', ['conv_op', 'block_shape_out', 'crops']) self.graph_sequence.set_outputs(['batch_to_space'])
def __init__(self): self.sequence = GraphSequence([ ConverterSequenceNode('a', ['Add']), ConverterSequenceNode('b', ['Rsqrt']), ConverterSequenceNode('c', ['Mul']), ConverterSequenceNode('d', ['Mul']), ConverterSequenceNode('e', ['Sub']), ConverterSequenceNode('f', ['Add']), # output NonConsumableConverterSequenceNode('inputs', ['?']), ConverterSequenceNode('mean', ['?']), ConverterSequenceNode('beta', ['?']), ConverterSequenceNode('variance', ['?']), ConverterSequenceNode('epsilon', ['?']) ]) self.sequence.set_inputs('a', ['variance', 'epsilon']) self.sequence.set_inputs('b', ['a']) self.sequence.set_inputs('c', ['b', 'inputs']) self.sequence.set_inputs('d', ['b', 'mean']) self.sequence.set_inputs('e', ['d', 'beta']) self.sequence.set_inputs('f', ['c', 'e']) self.sequence.set_outputs(['f'])
def __init__(self): self.sequence = GraphSequence([ NonConsumableConverterSequenceNode('input', ['?']), ConverterSequenceNode('StopGradient', ['StopGradient']), ConverterSequenceNode('SquaredDifference', ['SquaredDifference']), ConverterSequenceNode('variance', ['Mean']), ConverterSequenceNode('add', ['Add']), ConverterSequenceNode('mean', ['Mean']), NonConsumableConverterSequenceNode('gamma', ['Identity']), ConverterSequenceNode('Rsqrt', ['Rsqrt']), ConverterSequenceNode('mul_2', ['Mul']), NonConsumableConverterSequenceNode('beta', ['Identity']), ConverterSequenceNode('mul', ['Mul']), ConverterSequenceNode('sub', ['Sub']), ConverterSequenceNode('mul_1', ['Mul']), ConverterSequenceNode('add_1', ['Add']), NonConsumableConverterSequenceNode('stub_14', ['?']), NonConsumableConverterSequenceNode('stub_15', ['?']), NonConsumableConverterSequenceNode('stub_16', ['?']), NonConsumableConverterSequenceNode('stub_17', ['?']), NonConsumableConverterSequenceNode('stub_18', ['?']), ]) self.sequence.set_inputs('variance', ['SquaredDifference', 'stub_14']) self.sequence.set_inputs('StopGradient', ['mean']) self.sequence.set_inputs('add', ['variance', 'stub_15']) self.sequence.set_inputs('sub', ['beta', 'mul_2']) self.sequence.set_inputs('mean', ['input', 'stub_16']) self.sequence.set_inputs('gamma', ['stub_17']) self.sequence.set_inputs('mul_2', ['mean', 'mul']) self.sequence.set_inputs('Rsqrt', ['add']) self.sequence.set_inputs('beta', ['stub_18']) self.sequence.set_inputs('mul', ['Rsqrt', 'gamma']) self.sequence.set_inputs('add_1', ['mul_1', 'sub']) self.sequence.set_inputs('mul_1', ['input', 'mul']) self.sequence.set_inputs('SquaredDifference', ['input', 'StopGradient']) self.sequence.set_outputs(['add_1'])
# ============================================================================= # # Copyright (c) 2017-2019 Qualcomm Technologies, Inc. # All Rights Reserved. # Confidential and Proprietary - Qualcomm Technologies, Inc. # # ============================================================================= from snpe.converters.tensorflow.graph_matcher import ( ConverterSequenceNode, NonConsumableConverterSequenceNode, GraphSequence) box_decoder_sequence = GraphSequence([ NonConsumableConverterSequenceNode('Postprocessor/Tile', ['Tile']), ConverterSequenceNode('Postprocessor/Reshape_1', ['Reshape']), ConverterSequenceNode('Postprocessor/Reshape', ['Reshape']), ConverterSequenceNode('Postprocessor/Decode/transpose', ['Transpose']), ConverterSequenceNode('Postprocessor/Decode/div_3', ['RealDiv']), ConverterSequenceNode('Postprocessor/Decode/div_2', ['RealDiv']), ConverterSequenceNode( 'Postprocessor/Decode/get_center_coordinates_and_sizes/transpose', ['Transpose']), ConverterSequenceNode('Postprocessor/Decode/unstack', ['Unpack']), ConverterSequenceNode('Postprocessor/Decode/Exp', ['Exp']), ConverterSequenceNode( 'Postprocessor/Decode/get_center_coordinates_and_sizes/div_1', ['RealDiv']), ConverterSequenceNode( 'Postprocessor/Decode/get_center_coordinates_and_sizes/sub', ['Sub']), ConverterSequenceNode('Postprocessor/Decode/div_1', ['RealDiv']), ConverterSequenceNode('Postprocessor/Decode/Exp_1', ['Exp']), ConverterSequenceNode( 'Postprocessor/Decode/get_center_coordinates_and_sizes/div',
# ============================================================================= # # Copyright (c) 2018-2019 Qualcomm Technologies, Inc. # All Rights Reserved. # Confidential and Proprietary - Qualcomm Technologies, Inc. # # ============================================================================= from snpe.converters.tensorflow.graph_matcher import ( ConverterSequenceNode, NonConsumableConverterSequenceNode, GraphSequence) real_div_sequence = GraphSequence([ ConverterSequenceNode('root', ['RealDiv']), NonConsumableConverterSequenceNode('a', ['?']), NonConsumableConverterSequenceNode('b', ['?']) ]) real_div_sequence.set_inputs('root', ['a', 'b']) real_div_sequence.set_outputs(['root']) identity_sequence = GraphSequence([ ConverterSequenceNode('root', ['Identity']), NonConsumableConverterSequenceNode('any', ['?']), ]) identity_sequence.set_inputs('root', ['any']) identity_sequence.set_outputs(['root']) placeholder_with_default_sequence = GraphSequence([ ConverterSequenceNode('root', ['PlaceholderWithDefault']), NonConsumableConverterSequenceNode('any', ['?']), ]) placeholder_with_default_sequence.set_inputs('root', ['any']) placeholder_with_default_sequence.set_outputs(['root'])
def __init__(self): sequence_reshape = GraphSequence([ ConverterSequenceNode('root', ['Reshape', 'Squeeze', 'ExpandDims']) ]) sequence_reshape.set_outputs(['root']) sequence_flatten = GraphSequence([ NonConsumableConverterSequenceNode('input', ['?']), ConverterSequenceNode('shape', ['Shape']), ConverterSequenceNode('slice_1', ['Slice']), ConverterSequenceNode('const_1', ['Const']), ConverterSequenceNode('const_2', ['Const']), ConverterSequenceNode('slice_2', ['Slice']), ConverterSequenceNode('const_3', ['Const']), ConverterSequenceNode('const_4', ['Const']), ConverterSequenceNode('prod', ['Prod']), ConverterSequenceNode('const_5', ['Const']), ConverterSequenceNode('expand_dims', ['ExpandDims']), ConverterSequenceNode('const_6', ['Const']), ConverterSequenceNode('concat', ['ConcatV2']), ConverterSequenceNode('const_7', ['Const']), ConverterSequenceNode('root', ['Reshape']), ]) sequence_flatten.set_inputs('shape', ['input']) sequence_flatten.set_inputs('slice_1', ['shape', 'const_1', 'const_2']) sequence_flatten.set_inputs('slice_2', ['shape', 'const_3', 'const_4']) sequence_flatten.set_inputs('prod', ['slice_2', 'const_5']) sequence_flatten.set_inputs('expand_dims', ['prod', 'const_6']) sequence_flatten.set_inputs('concat', ['slice_1', 'expand_dims', 'const_7']) sequence_flatten.set_inputs('root', ['input', 'concat']) sequence_flatten.set_outputs(['root']) # consume shape op # pattern: shape -> concat -> reshape sequence_shape_concat = GraphSequence([ NonConsumableConverterSequenceNode('input', ['?']), ConverterSequenceNode('shape', ['Shape']), ConverterSequenceNode('const_1', ['Const']), ConverterSequenceNode('const_2', ['Const']), ConverterSequenceNode('concat', ['ConcatV2']), ConverterSequenceNode('root', ['Reshape']), ]) sequence_shape_concat.set_inputs('shape', ['input']) sequence_shape_concat.set_inputs('concat', ['shape', 'const_1', 'const_2']) sequence_shape_concat.set_inputs('root', ['concat', 'input']) sequence_shape_concat.set_outputs(['root']) # consume shape op # pattern: shape -> strideslice -> stack -> reshape sequence_shape_stridedslice_stack = GraphSequence([ NonConsumableConverterSequenceNode('input', ['?']), ConverterSequenceNode('shape', ['Shape']), ConverterSequenceNode('stridedslice', ['StridedSlice']), ConverterSequenceNode('const_1', ['Const']), ConverterSequenceNode('const_2', ['Const']), ConverterSequenceNode('const_3', ['Const']), ConverterSequenceNode('const_4', ['Const']), ConverterSequenceNode('const_5', ['Const']), ConverterSequenceNode('stack', ['Pack']), ConverterSequenceNode('root', ['Reshape']), ]) sequence_shape_stridedslice_stack.set_inputs('shape', ['input']) sequence_shape_stridedslice_stack.set_inputs( 'stridedslice', ['shape', 'const_1', 'const_2', 'const_3']) sequence_shape_stridedslice_stack.set_inputs( 'stack', ['stridedslice', 'const_4', 'const_5']) sequence_shape_stridedslice_stack.set_inputs('root', ['input', 'stack']) sequence_shape_stridedslice_stack.set_outputs(['root']) self.sequences = [ sequence_reshape, sequence_flatten, sequence_shape_concat, sequence_shape_stridedslice_stack ]