def infer(node: None): input_shape = node.in_node(0).shape name = node.soft_get('name', node.id) axes = node.axes if axes is not None: if 0 in axes: raise Error('Reduction over the batch dimension in node "{}" ' 'is not supported by the backend.'.format(name)) for i in range(2, len(input_shape)): if i not in axes: raise Error( 'Reduction over spatial dimensions in node "{}" ' 'is obligatory for the backend.'.format(name)) if 1 in axes and not node.across_channels: raise Error( 'Inconsistent values of axes ({}) and across_channels ({}) parameters ' 'in node "{}".'.format(str(axes), str(node.across_channels), name)) copy_shape_infer(node)
def __init__(self, graph: Graph, attrs: dict): super().__init__( graph, { 'op': self.op, 'type': None, 'version': None, 'infer': lambda n: copy_shape_infer(n, copy_value), 'type_infer': None, 'in_ports_count': 1, 'out_ports_count': 1, }, attrs)
def test_region_infer(self): graph = build_graph( nodes_attributes, [('node_1', 'norm'), ('norm', 'node_3'), ('node_3', 'op_output')], { 'node_3': { 'shape': None }, 'node_1': { 'shape': np.array([1, 3, 227, 227]), 'value': None }, 'norm': {} }) norm_node = Node(graph, 'norm') copy_shape_infer(norm_node) exp_shape = np.array([1, 3, 227, 227]) res_shape = graph.node['node_3']['shape'] for i in range(0, len(exp_shape)): self.assertEqual(exp_shape[i], res_shape[i])
def infer(node: Node): if len(node.in_nodes()) > 0: # In case this is a memory node with input, # It should not have output # However in order not to break MO pipeline, # we just set the same shape to the output # node that will be removed later in pipeline copy_shape_infer(node) return elif node.has_valid('shape'): # For Memories, that has not input infer shapes is very difficult # But often we can know shape in extracting attributes # And we can set the attribute 'shape' in extracting batch = 1 for out_node in node.out_nodes().values(): out_node.shape = [batch, *node.shape[:]] return else: raise Error('Model Optimizer is unable to calculate output shape of Memory node {}. ' + refer_to_faq_msg(88), node.id)
def test_grn_infer(self): graph = build_graph( nodes_attributes, [('node_1', 'grn'), ('grn', 'node_3')], { 'node_3': { 'is_output': True, 'shape': None }, 'node_1': { 'shape': np.array([1, 3, 227, 227]) }, 'grn': { 'bias': 1 } }) grn_node = Node(graph, 'grn') copy_shape_infer(grn_node) exp_shape = np.array([1, 3, 227, 227]) res_shape = graph.node['node_3']['shape'] for i in range(0, len(exp_shape)): self.assertEqual(exp_shape[i], res_shape[i])
def infer(node: Node): assert node.has_valid( 'dst_type' ), 'Destination type of "Cast" operation should be extracted earlier' dst_type = node.dst_type copy_shape_infer(node) if node.in_node(0).has_valid('value'): new_blob, finite_match_count, zero_match_count = convert_blob( node.in_node(0).value, dst_type) node.out_port(0).data.set_value(new_blob) if finite_match_count: log.error(( "{} elements of {} were clipped to infinity while converting an input blob for node '{}' to {}. " + refer_to_faq_msg(76)).format(finite_match_count, new_blob.size, node.name, dst_type)) if zero_match_count: log.warning(( "{} elements of {} were clipped to zero while converting an input blob for node '{}' to {}. " + refer_to_faq_msg(77)).format(zero_match_count, new_blob.size, node.name, dst_type))
def infer(node: Node): # MemoryOffset is splitted in 2 parts to avoid cycle in graph # Calculate shape from shape of previous layer where possible # In other cases information about shapes from initial Kaldi model used if not node.in_port(0).disconnected(): copy_shape_infer(node) pair_node = Node(node.graph, node.pair_name) pair_node.out_port(0).data.set_shape( node.out_port(0).data.get_shape()) else: pair_node = Node(node.graph, node.pair_name) if pair_node.in_port(0).data.get_shape() is not None: node.out_port(0).data.set_shape( pair_node.in_port(0).data.get_shape()) copy_shape_infer(pair_node) elif pair_node.has_valid('element_size'): # TODO Add here real batch node.out_port(0).data.set_shape( np.array([1, pair_node['element_size']])) elif pair_node.in_port(0).get_source().node.has_valid('out-size'): out_size = pair_node.in_port(0).get_source().node['out-size'] node.out_port(0).data.set_shape(np.array([1, out_size])) elif pair_node.in_port(0).get_source().node.op in ["Add", "ReLU"] and \ pair_node.in_port(0).get_source().node.in_port(0).get_source().node.has_valid('out-size'): out_size = pair_node.in_port(0).get_source().node.in_port( 0).get_source().node['out-size'] node.out_port(0).data.set_shape(np.array([1, out_size])) elif pair_node.in_port(0).get_source().node.has_valid('in_dim'): out_size = pair_node.in_port(0).get_source().node['in_dim'] node.out_port(0).data.set_shape(np.array([1, out_size])) else: raise Error( "Can't calculate MemoryOffset shape for node {}. ".format( node.id) + "Possibly you need to add shape for it through --input_shape" )
def test_copy_shape_infer(self, single_output_infer_mock): single_output_infer_mock.return_value = 0 node = FakeNode(np.array([1, 2])) copy_shape_infer(node) self.assertTrue(single_output_infer_mock.called)
def shape_infer(node): copy_shape_infer(node)
def batch_norm_4_infer(node: Node): copy_shape_infer(node) mark_input_bins(node, ['weights', 'biases', 'mean', 'variance']) if node.has('fix_gamma') and node.fix_gamma: # go to the 1-st input weights and set all elements to 1 node.in_node(1).value = np.full_like(node.in_node(1).value, 1, dtype=np.float32)
def infer(node: Node): if node.axis < 0: node.axis = len(node.in_node().shape) + node.axis copy_shape_infer(node) PermuteAttrs.create_permute_attrs(node, attrs=[('axis', 'input:0')])
def infer(node: Node): assert node.has_valid('dst_type'), 'Destination type of "Cast" operation should be extracted earlier' copy_shape_infer(node, lambda n: n.in_node().value.astype(n.dst_type))
def infer(node: Node): mark_input_bins(node) copy_shape_infer(node)
def roll_infer(node: Node): PermuteInputs().set_input_permutation(node.in_node(2), node, 'input:0', 'axis') copy_shape_infer(node)
def infer(node: Node): # we just set the same shape to the output copy_shape_infer(node)
def shape_infer(node): copy_shape_infer(node, value_infer=copy_value)
def infer(node: Node): if node.axis < 0: node.axis = len(node.in_node().shape) + node.axis copy_shape_infer(node)
def infer(node: Node): copy_shape_infer(node, lambda n: n.in_node().value.astype(n.dst_type))