def test_dropout_trans(droput_graph_tuple): (graph_def, (keep_prob_name, dropout_output_name), output_nodes) = droput_graph_tuple ugraph = uTensorGraph(graph_def, output_nodes=output_nodes) transformer = DropoutTransformer() new_ugraph = transformer.transform(ugraph) # all dropout nodes should be gone graph_1 = tf.Graph() graph_2 = tf.Graph() with graph_1.as_default(): tf.import_graph_def(ugraph.graph_def, name='') with graph_2.as_default(): tf.import_graph_def(new_ugraph.graph_def, name='') with tf.Session(graph=graph_1) as sess: keep_prob = graph_1.get_tensor_by_name(keep_prob_name) dropout_output = graph_1.get_tensor_by_name(dropout_output_name) output = graph_1.get_tensor_by_name(output_nodes[0] + ":0") # test the dropout ops are gone assert keep_prob.op.name not in new_ugraph.ops_info assert dropout_output.op.name not in new_ugraph.ops_info output_1 = output.eval({keep_prob: 1.0}) with tf.Session(graph=graph_2) as sess: output = graph_2.get_tensor_by_name(output_nodes[0] + ":0") output_2 = output.eval() # expecting the same outputs with keep_prob == 1.0 assert (output_1 == output_2).all()
def test_ugraph_copy(graph_tuple): graph_def, output_nodes = graph_tuple ugraph_1 = uTensorGraph(graph_def, output_nodes=output_nodes) ugraph_2 = deepcopy(ugraph_1) assert ugraph_1 is not ugraph_2 assert ugraph_1.graph_def == ugraph_2.graph_def
def __call__(self, match): op_name = 'quant_conv_pool' repl_ugraph = uTensorGraph(name='{}_repl_graph'.format(op_name), output_nodes=[op_name], lib_name=match.subject_ugraph.lib_name) subj_conv_op = match.patrn2subj_op_map['conv/eightbit'] subj_pool_op = match.patrn2subj_op_map['maxpool/eightbit'] output_tensors = [ TensorInfo(name='{}:{}'.format(op_name, i), op_name=op_name, dtype=subj_tensor.dtype, shape=subj_tensor.shape, ugraph=repl_ugraph) for i, subj_tensor in enumerate(subj_pool_op.output_tensors) ] input_tensors = [ TensorInfo.make_null_tensor(ugraph=repl_ugraph) for _ in subj_conv_op.input_tensors ] quant_conv2d_pool_op = OperationInfo( name=op_name, input_tensors=input_tensors, n_inputs=len(input_tensors), output_tensors=output_tensors, n_outputs=len(output_tensors), op_type='QuantizedFusedConv2DMaxpool', lib_name=subj_conv_op.lib_name, op_attr={ '_utensor_conv': subj_conv_op.op_attr, '_utensor_pool': subj_pool_op.op_attr, }, ugraph=repl_ugraph) topologic_order_graph(repl_ugraph) input_map = { match.pattern_ugraph['conv/eightbit'].input_tensors[0]: quant_conv2d_pool_op.input_tensors[0], match.pattern_ugraph['conv/eightbit'].input_tensors[1]: quant_conv2d_pool_op.input_tensors[1], match.pattern_ugraph['conv/eightbit'].input_tensors[2]: quant_conv2d_pool_op.input_tensors[2], match.pattern_ugraph['conv/eightbit'].input_tensors[3]: quant_conv2d_pool_op.input_tensors[3], match.pattern_ugraph['conv/eightbit'].input_tensors[4]: quant_conv2d_pool_op.input_tensors[4], match.pattern_ugraph['conv/eightbit'].input_tensors[5]: quant_conv2d_pool_op.input_tensors[5], } output_map = { match.pattern_ugraph['maxpool/eightbit'].output_tensors[0]: output_tensors[0], match.pattern_ugraph['maxpool/eightbit'].output_tensors[1]: output_tensors[1], match.pattern_ugraph['maxpool/eightbit'].output_tensors[2]: output_tensors[2], } return repl_ugraph, input_map, output_map
def test_refcnt_optimizer(refgraph_tuple): (graph_def, refcnt_ans, output_nodes)= refgraph_tuple ugraph = uTensorGraph(graph_def, output_nodes) transformer = RefCntOptimizer() ugraph = transformer.transform(ugraph) for node_name in ugraph.topo_order: if node_name in refcnt_ans: op_info = ugraph.ops_info[node_name] refcnts = op_info.op_attr["%s__ref_counts" % transformer.KWARGS_NAMESCOPE] assert refcnts == refcnt_ans[node_name]
def test_ugraph_topo_order(graph_tuple): graph_def, output_nodes = graph_tuple ugraph = uTensorGraph(graph_def, output_nodes=output_nodes) first_out, second_out = output_nodes meet_first = False for node_name in ugraph.topo_order: if node_name == first_out: meet_first = True if node_name == second_out: assert meet_first
def test_in_out_nodes(graph_tuple): ugraph = uTensorGraph(*graph_tuple) x3 = ugraph.ops_info['x3'] assert x3.ugraph is ugraph assert len(x3.input_nodes) == len(set([op.name for op in x3.input_nodes])) assert all([str(op.name) in ['x2', 'bias2'] for op in x3.input_nodes]) assert x3.output_nodes == [] x2 = ugraph.ops_info['x2'] assert [str(op.name) for op in x2.output_nodes] == ['x3']
def test_inline_optimizer(inlinegraph_tuple): (graph_def, inline_ans, output_nodes) = inlinegraph_tuple ugraph = uTensorGraph(graph_def, output_nodes) transformer = InlineTransformer() ugraph = transformer.transform(ugraph) for op in ugraph.ops_info.values(): assert not op.is_dangling for node_name in ugraph.topo_order: if node_name in inline_ans: op_type = ugraph.ops_info[node_name].op_type assert op_type == 'Inline'
def show_pb_file(pb_file, oneline=False): import tensorflow as tf from utensor_cgen.ir import uTensorGraph import textwrap _, ext = os.path.splitext(pb_file) if ext == '.pb': graph_def = tf.GraphDef() with open(pb_file, 'rb') as fid: graph_def.ParseFromString(fid.read()) ugraph = uTensorGraph( graph=graph_def, output_nodes=[node.name for node in graph_def.node]) else: msg = click.style('unknown file extension: {}'.format(ext), fg='red', bold=True) click.echo(msg, file=sys.stderr) if oneline: tmpl = click.style("{op_name} ", fg='yellow', bold=True) + \ "op_type: {op_type}, inputs: {inputs}, outputs: {outputs}" for op_name in ugraph.topo_order: op_info = ugraph.ops_info[op_name] msg = tmpl.format( op_name=op_name, op_type=op_info.op_type, inputs=[tensor.name for tensor in op_info.input_tensors], outputs=[tensor.name for tensor in op_info.output_tensors]) click.echo(msg) else: tmpl = click.style('op_name: {op_name}\n', fg='yellow', bold=True) + \ '''\ op_type: {op_type} input(s): {inputs} ouptut(s): {outputs} ''' tmpl = textwrap.dedent(tmpl) paragraphs = [] for op_name in ugraph.topo_order: op_info = ugraph.ops_info[op_name] op_str = tmpl.format(op_name=op_name, op_type=op_info.op_type, inputs=op_info.input_tensors, outputs=op_info.output_tensors) paragraphs.append(op_str) click.echo('\n'.join(paragraphs)) return 0
def test_ugraph_build_ctx(): from utensor_cgen.ir import uTensorGraph from utensor_cgen.ir.graph_builder import GraphFinalizedError ugraph = uTensorGraph() with ugraph.begin_construction(): ugraph.add_op(op_type='Const', name='x', value=np.array([1]), is_output=True) assert ugraph.is_finalized assert ugraph.output_nodes == ['x'] try: ugraph.add_op(op_type='Const', name='y', value=np.array([2])) except GraphFinalizedError: pass
def parse(self, onnx_file, output_nodes=None, model_name=None): tf.disable_eager_execution() if model_name: graph_name = model_name else: graph_name, _ = os.path.splitext(os.path.basename(onnx_file)) tf.reset_default_graph() model = onnx.load(onnx_file) onnx_graph = model.graph ugraph = uTensorGraph( name=graph_name, output_nodes=[], lib_name='onnx', ops_info={}, ) self._build_graph(onnx_graph, ugraph) ugraph = Legalizer.legalize(ugraph) tf.reset_default_graph() return ugraph
def parse(self, txt_file, output_nodes=None): graph_name, _ = os.path.splitext( os.path.basename(txt_file) ) if output_nodes is None: output_nodes = [] add_all_nodes = not output_nodes ugraph = uTensorGraph(name=graph_name, output_nodes=output_nodes, lib_name='txtlib') with open(txt_file, 'r') as fid: for line in fid: try: op_name, value = line.split(' ', maxsplit=1) except Exception: raise ValueError('invalid line: {}'.format(line)) value = np.array(eval(value)) out_tensor = TensorInfo( '{}:0'.format(op_name), op_name, dtype=value.dtype, shape=list(value.shape), ugraph=ugraph ) op_info = OperationInfo( name=op_name, lib_name='txtlib', ugraph=ugraph, input_tensors=[], output_tensors=[out_tensor], op_type='Const', op_attr={ "value": AttrValueConverter.GenericType( value_name="tensor", value=GenericTensorConverterMixin.GenericType( np_array=value ), ) } ) if add_all_nodes: ugraph.output_nodes.append(op_name) topologic_order_graph(ugraph) return ugraph
def transform(self, ugraph): new_graph = uTensorGraph() dropout_input_map = self._find_input(ugraph) new_ops_info = {} for node_name in ugraph.topo_order: match = self.TARGET_NODENAME_PATTERN.match(node_name) if match: # ignore all dropout nodes continue # replace inputs with dropout inputs op_info = ugraph.ops_info[node_name] in_t_infos = [ deepcopy(t_info, {'ugraph': new_graph}) for t_info in op_info.input_tensors ] out_t_infos = [ deepcopy(t_info, {'ugraph': new_graph}) for t_info in op_info.output_tensors ] op_attr = deepcopy(op_info.op_attr) for i, t_info in enumerate(in_t_infos): op_name = parse_tensor_name(t_info.name)[0] match = self.TARGET_NODENAME_PATTERN.match(op_name) if match: name_scope = match.group(1) # assume there should be only on input except keep_prob dropout_in_tensor = dropout_input_map[name_scope] in_t_infos.pop(i) in_t_infos.insert(i, dropout_in_tensor) new_op_info = OperationInfo(name=op_info.name, input_tensors=in_t_infos, output_tensors=out_t_infos, op_type=op_info.op_type, backend=op_info.backend, op_attr=op_attr, ugraph=new_graph) new_ops_info[node_name] = new_op_info new_graph.ops_info = new_ops_info new_graph.output_nodes = ugraph.output_nodes new_graph._backend = ugraph._backend return new_graph
def test_op_info(): np_array = np.array([1, 2, 3], dtype=np.float32) t_proto = tf.make_tensor_proto(np_array, dtype=np.float32) ugraph = uTensorGraph() op_info = OperationInfo(name='testing_op', input_tensors=[], output_tensors=[], op_type='no_op', backend='tensorflow', op_attr={ '_utensor_to_skip': [1, 2, 3], '_utensor_skip_this_too': None, 'tensor_no_skip': t_proto }, ugraph=ugraph) assert op_info.op_attr.get('_utensor_to_skip', None) == [1, 2, 3] assert op_info.op_attr.get('_utensor_skip_this_too') is None generic_tensor = op_info.op_attr.get('tensor_no_skip') assert isinstance(generic_tensor, TensorProtoConverter.__utensor_generic_type__) assert (generic_tensor.np_array == np_array).all() assert op_info.name in ugraph.ops_info
def test_tensor_ops(graph_tuple): ugraph = uTensorGraph(*graph_tuple) for op in ugraph.ops_info.values(): for tensor in op.output_tensors: assert tensor.op is op
def _ugraph(): from utensor_cgen.ir import uTensorGraph return uTensorGraph(output_nodes=[])