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=[])
