def extract(cls, node):
shape = shape_array([])
# Extract output shape from `shape` attribute
extracted_shape = tf_tensor_shape(node.pb.attr["shape"].shape)
if len(extracted_shape) != 0:
shape = extracted_shape
else:
# Extract output shape from `_output_shapes` attribute if it is possible
extracted_output_shapes = node.pb.attr["_output_shapes"].list.shape
if len(extracted_output_shapes) == 1: # check if attribute not empty
extracted_output_shapes = tf_tensor_shape(extracted_output_shapes[0])
# Check equality of extracted shapes. We know some cases then Placeholder operation has empty `shape`
# attribute value and non-empty `_output_shapes` attribute value and need co handle and support it.
if len(extracted_output_shapes) > len(extracted_shape):
log.warning('Extracted shapes for Placeholder operation {} have different lengths: `shape` {} and '
'`_output_shapes` {}. Please, check if model is consistent'.format(
node.pb.name, extracted_shape, extracted_output_shapes))
if len(extracted_output_shapes) != 0:
shape = extracted_output_shapes
attrs = {
'data_type': tf_dtype_extractor(node.pb.attr["dtype"].type),
'shape': shape,
'permute_attrs': PermuteAttrs().update_attrs(attrs=[('shape', 'output:0')])
}
if node.pb.attr["shape"].shape.unknown_rank:
attrs['shape'] = None
Parameter.update_node_stat(node, attrs)
return cls.enabled
def generate_feed_dict(graph: tf_v1.Graph, node: Node):
"""
The first value in the return tuple is True if all inputs for the node has constant values.
The second returned value is mapping of placeholder tensor to the numpy arrays with the values for these
placeholders.
:param graph: the TensorFlow Graph to generate feed dictionary to.
:param node: the node which represents TensorFlow sub-graph of operations.
:return: pair where the first element is a flag that specifies that all node inputs are constants and a dictionary
where key is the input Tensor object and the value is the tensor value.
"""
all_constants = True
feed_dict = dict()
for in_data_node_name, edge_attrs in node.get_inputs():
if 'control_flow_edge' in edge_attrs and edge_attrs[
'control_flow_edge']:
continue
value = node.in_node(edge_attrs['in']).value
if value is None:
all_constants = False
placeholder_pb = node['pbs'][edge_attrs['placeholder_name']]
value = np.ones(
shape=tf_tensor_shape(placeholder_pb.attr['shape'].shape),
dtype=tf_dtype_extractor(placeholder_pb.attr['dtype'].type))
feed_dict[graph.get_tensor_by_name(edge_attrs['placeholder_name'] +
":0")] = value
return all_constants, feed_dict
def extract(cls, node: Node):
attrs = {
'op': __class__.op,
'element_shape': tf_tensor_shape(node.pb.attr["element_shape"].shape),
}
TensorArrayGather.update_node_stat(node, attrs)
return cls.enabled
def extract(cls, node):
attrs = {
'data_type': tf_dtype_extractor(node.pb.attr["dtype"].type),
'shape': tf_tensor_shape(node.pb.attr["shape"].shape),
'identity': True,
'infer': lambda node: copy_shape_infer(node, value_infer=copy_value),
}
Op.update_node_stat(node, attrs)
return cls.enabled
def extract(cls, node):
pb_tensor = node.pb.attr["value"].tensor
shape = tf_tensor_shape(pb_tensor.tensor_shape)
attrs = {
'shape': shape,
'value': tf_tensor_content(pb_tensor.dtype, shape, pb_tensor),
'data_type': tf_dtype_extractor(pb_tensor.dtype),
}
Const.update_node_stat(node, attrs)
return cls.enabled
def extract(cls, node):
attrs = {
'data_type': tf_dtype_extractor(node.pb.attr["dtype"].type),
'shape': tf_tensor_shape(node.pb.attr["shape"].shape),
'permute_attrs': PermuteAttrs().update_attrs(attrs=[('shape', 'output:0')])
}
if node.pb.attr["shape"].shape.unknown_rank:
attrs['shape'] = None
Parameter.update_node_stat(node, attrs)
return cls.enabled
def update_placeholder_shape_and_add_transpose(node: Node):
"""
The function changes placeholders shapes from NHWC to NCHW format and add transpose operations if needed.
:param node: node to operate on.
:return: None
"""
try:
import tensorflow.compat.v1 as tf_v1
# disable eager execution of TensorFlow 2 environment immediately
tf_v1.disable_eager_execution()
except ImportError:
import tensorflow as tf_v1
from openvino.tools.mo.front.common.layout import convert_shape, nhwc_to_nchw_permute, nchw_to_nhwc_permute
from openvino.tools.mo.front.tf.extractors.utils import tf_tensor_shape
from openvino.tools.mo.front.tf.partial_infer.tf import add_node_def_to_subgraph, update_input_in_pbs
tf_v1.reset_default_graph()
inputs_replacements = list()
# transpose permutation constant
nchw_to_nhwc_constant = tf_v1.constant(nchw_to_nhwc_permute, dtype=tf_v1.int32, name=nchw_to_nhwc_constant_name)
nhwc_to_nchw_constant = tf_v1.constant(nhwc_to_nchw_permute, dtype=tf_v1.int32, name=nhwc_to_nchw_constant_name)
for placeholder_name in node['input_nodes_names']:
# dummy node which we can refer to as input in the transpose for the output node
# dummy node should be unique for each placeholder
dummy_node = tf_v1.constant(value=[[[[1]]]], dtype=tf_v1.float32,
name='random_dummy_name_' + placeholder_name)
placeholder = node['pbs'][placeholder_name]
cur_shape = tf_tensor_shape(placeholder.attr['shape'].shape)
if len(cur_shape) == 4: # TODO think about better check that transpose is required
nchw_shape = convert_shape(cur_shape, nhwc_to_nchw_permute)
for ind in range(len(cur_shape)):
placeholder.attr['shape'].shape.dim[ind].size = nchw_shape[ind]
transpose_name = placeholder.name + '_transpose'
transpose = tf_v1.transpose(dummy_node, nchw_to_nhwc_constant, transpose_name) # NCHW -> NHWC
# add transpose operations to GraphDef after placeholders
add_node_def_to_subgraph(node, transpose.op.node_def, transpose_name, len(node['input_nodes_names']))
inputs_replacements.append((placeholder.name, transpose_name))
inputs_replacements.append((dummy_node.name, placeholder.name))
node['real_input_dims'].append(nchw_shape)
else:
node['real_input_dims'].append(cur_shape)
add_node_def_to_subgraph(node, nchw_to_nhwc_constant.op.node_def)
add_node_def_to_subgraph(node, nhwc_to_nchw_constant.op.node_def)
# update initial input names to a transposed ones
for old_input_tensor_name, new_name in inputs_replacements:
update_input_in_pbs(node, old_input_tensor_name, new_name)
def extract(cls, node):
shapes = node.pb.attr['output_shapes'].list.shape
tf_types = node.pb.attr['output_types'].list.type
extracted_types = []
for t in tf_types:
extracted_types.append(tf_dtype_extractor(t))
result_shapes = []
for shape_pb in shapes:
result_shapes.append(tf_tensor_shape(shape_pb))
Op.update_node_stat(
node, {
'shapes': result_shapes,
'types': extracted_types,
'out_ports_count': 1
})
return cls.enabled
def get_attrs(node: Node):
shapes = node.pb.attr["_output_shapes"].list.shape
tf_types = node.pb.attr["component_types"].list.type
extracted_types = []
for t in tf_types:
extracted_types.append(tf_dtype_extractor(t))
result_shapes = []
for shape_pb in shapes:
result_shapes.append(tf_tensor_shape(shape_pb))
assert len(result_shapes) == len(extracted_types), "Output shapes do not match output" \
"types in the node {}".format(node.soft_get('name', node.id))
attrs = {
"shapes": result_shapes,
"types": extracted_types,
'out_ports_count': len(result_shapes)
}
return attrs