def extract(cls, node): data_type = tf_dtype_extractor(node.pb.attr["T"].type) AttributedPower.update_node_stat(node, { 'power': data_type(2), 'data_type': data_type }) return cls.enabled
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 extract(cls, node): BiasAdd.update_node_stat( node, { 'data_type': tf_dtype_extractor(node.pb.attr["T"].type), 'data_format': node.pb.attr["data_format"].s.decode() }) 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): Size.update_node_stat( node, { 'output_type': tf_dtype_extractor(node.pb.attr['out_type'].type, np.int32) }) return cls.enabled
def extract(cls, node: Node): dtypes = [tf_dtype_extractor(t) for t in node.pb.attr["T"].list.type] IdentityN.update_node_stat(node, { 'data_types': dtypes, 'in_ports_count': len(dtypes), 'out_ports_count': len(dtypes), }) return cls.enabled
def extract(cls, node): attrs = { 'output_type': tf_dtype_extractor(node.pb.attr["dtype"].type), 'global_seed': node.pb.attr['seed'].i, 'op_seed': node.pb.attr['seed2'].i } AttributedRandomUniform.update_node_stat(node, attrs) return cls.enabled
def extract(cls, node): OneHot.update_node_stat( node, { 'axis': node.pb.attr['axis'].i, 'data_type': tf_dtype_extractor(node.pb.attr["T"].type, np.float32) }) 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 tf_fused_bn_extractor(pb): is_training = pb.attr['is_training'].b if is_training: log.warning('FusedBatchNorm doesn\'t support is_training=True') return { 'data_format': pb.attr["data_format"].s, 'data_type': tf_dtype_extractor(pb.attr["T"].type), 'eps': pb.attr['epsilon'].f, 'infer': tf_fused_bn_infer, 'is_training': is_training }
def tf_fused_bn_extractor(pb): is_training = pb.attr['is_training'].b if is_training: log.warning('FusedBatchNorm doesn\'t support is_training=True') return { 'data_format': pb.attr["data_format"].s.decode(), 'data_type': tf_dtype_extractor(pb.attr["T"].type), 'eps': pb.attr['epsilon'].f, 'infer': tf_fused_bn_infer, 'reverse_infer': lambda node: reverse_bypass_infer(node, in_ports=[0]), 'is_training': is_training }
def determine_data_type(node: Node): """ Tries to determine data type of the node. The input node could be either data or op node. If we don't know the data type of the node then we recursively check the first parent of the node. :param node: node to determine data type. :return: data type of the node output in the numpy format. """ if node.has_and_set('data_type'): return node.data_type if node.has_and_set('kind') and node.kind == 'op': if node.has_and_set('pb'): if 'dtype' in node.pb.attr: return tf_dtype_extractor(node.pb.attr['dtype'].type) if 'T' in node.pb.attr: return tf_dtype_extractor(node.pb.attr['T'].type) if node.has_and_set('kind') and node.kind == 'data': if 'value' in node and node.value is not None: return node.value.dtype if len(node.in_nodes()) != 0: # try to guess data type from the first parent return determine_data_type(node.in_node(0)) log.error('Failed to determine data type for node "{}"'.format(node.name)) return None
def extract(cls, node): attrs = { 'top_k': 1, 'axis': None, 'keepdims': 0, 'remove_values_output': True, 'output_type': tf_dtype_extractor(node.pb.attr['output_type'].type, np.int64) } ArgMinOp.update_node_stat(node, attrs) return cls.enabled
def extract(cls, node): shapes = node.pb.attr['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: shape = shape_pb.dim if len(shape) == 3: result_shapes.append(int64_array([1, shape[0].size, shape[1].size, shape[2].size])) else: result_shapes.append(int64_array([dim.size for dim in shape])) Op.update_node_stat(node, {'shapes': result_shapes, 'types': extracted_types}) return cls.enabled
def replace_sub_graph(self, graph: Graph, match: dict): node = match['op'] if not node.has_valid('value'): log.debug("No value in FakeConst node {}".format(node.id)) return node_value = node.value extracted_attrs = { 'data_type': tf_dtype_extractor(node.pb.attr['dtype'].type), 'shape': int64_array(node_value.shape), 'value': node_value } Const.update_node_stat(node, extracted_attrs) log.debug( 'FakeConst op was translated to Const op with shape = {} and value.shape = {}' ''.format(extracted_attrs['shape'], extracted_attrs['value'].shape))
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
def extract(cls, node): ArgMaxOp.update_node_stat( node, { 'out_max_val': 0, 'top_k': 1, 'axis': None, 'dim_attrs': ['axis'], 'keepdims': 0, 'remove_values_output': True, 'output_type': tf_dtype_extractor(node.pb.attr['output_type'].type, np.int64), }) return cls.enabled
def convert_graph_inputs_to_parameters(internal_graph, internal_graph_proto): # create Parameter nodes for the body graph body_parameters = [] body_parameter_names = [] for idx, pb_node in enumerate(internal_graph_proto['input_arg']): param_id = internal_graph.unique_id(pb_node.name) internal_graph.add_node(param_id, name=param_id, kind='op', op='Parameter', pb=None, shape=None) parameter_node = Node(internal_graph, pb_node.name) Parameter.update_node_stat( parameter_node, { 'data_type': tf_dtype_extractor(pb_node.type), 'permute_attrs': PermuteAttrs().update_attrs(attrs=[('shape', 'output:0')]) }) body_parameters.append(parameter_node) body_parameter_names.append(param_id) return body_parameters, body_parameter_names
def extract(cls, node): SquaredDifference.update_node_stat(node, {'data_type': tf_dtype_extractor(node.pb.attr["T"].type)}) return cls.enabled
def extract(cls, node): Minimum.update_node_stat(node, {'data_type': tf_dtype_extractor(node.pb.attr["T"].type)}) return cls.enabled
def extract(cls, node: Node): Identity.update_node_stat( node, { 'data_type': tf_dtype_extractor(node.pb.attr["T"].type), }) return cls.enabled
def extract(cls, node: Node): Range.update_node_stat(node, {'output_type': tf_dtype_extractor(node.pb.attr['Tidx'].type)}) return cls.enabled