def test_conv_add_relu(self):
tf.compat.v1.disable_eager_execution()
x = tf.compat.v1.placeholder(tf.float32, [1, 224, 224, 3], name="input")
conv_weights = tf.compat.v1.get_variable("weight", [3, 3, 3, 32],
initializer=tf.compat.v1.random_normal_initializer())
conv_bias = tf.compat.v1.get_variable("bias", [32],
initializer=tf.compat.v1.random_normal_initializer())
conv1 = tf.nn.conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="SAME")
conv_bias=tf.math.add(conv1, conv_bias)
relu=tf.nn.relu(conv_bias)
with tf.compat.v1.Session() as sess:
sess.run(tf.compat.v1.global_variables_initializer())
output_graph_def = graph_util.convert_variables_to_constants(
sess=sess,
input_graph_def=sess.graph_def,
output_node_names=[relu.name.split(':')[0]])
output_graph_def = QuantizeGraphHelper.remove_training_nodes(
output_graph_def, protected_nodes=[relu.name.split(':')[0]])
graph_def = copy.deepcopy(output_graph_def)
inputs = ['input']
outputs = [relu.name.split(':')[0]]
op_wise_config = {
"Conv2D": (False, 'minmax', False),
}
graph_def=output_graph_def
fold_graph_def = QuantizeGraphForIntel(output_graph_def,outputs,
op_wise_config,
'cpu').do_transform()
found_QuantizedConv2DWithBiasAndRelu = False
for i in fold_graph_def.node:
if i.op == 'QuantizedConv2DWithBiasAndRelu':
found_QuantizedConv2DWithBiasAndRelu = True
break
self.assertEqual(found_QuantizedConv2DWithBiasAndRelu, True)
def test_first_matmul_biasadd_relu_fusion(self):
import numpy as np
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
y_data = np.array([[1, 2], [3, 4]], dtype=np.float)
x = tf.placeholder(tf.float32, shape=[2, 2])
y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
z = tf.matmul(x, y)
z = tf.nn.bias_add(z, [1, 2])
z = tf.nn.relu(z)
with tf.Session() as sess:
sess.run(z, feed_dict={x: x_data, y: y_data})
float_graph_def = sess.graph.as_graph_def()
float_graph_def = QuantizeGraphHelper().get_sorted_graph(
float_graph_def, ['Placeholder'], ['Relu'])
worker = FuseNodeStartWithMatmul(float_graph_def, 'MatMul', False,
'MatMul', 'cpu', True)
output_graph = worker.apply_the_transform()
found_quantized_matmul = False
for i in output_graph.node:
if i.op == 'QuantizeV2' and i.name == 'MatMul_eightbit_quantize_Placeholder' and i.attr[
"T"].type == dtypes.quint8:
found_quantized_matmul = True
break
self.assertEqual(found_quantized_matmul, True)
class TestFoldBatchnorm(unittest.TestCase):
tf.compat.v1.disable_eager_execution()
x = tf.compat.v1.placeholder(tf.float32, [1, 224, 224, 3], name="input")
conv_weights = tf.compat.v1.get_variable(
"weight", [3, 3, 3, 32],
initializer=tf.compat.v1.random_normal_initializer())
conv_bias = tf.compat.v1.get_variable(
"bias", [32], initializer=tf.compat.v1.random_normal_initializer())
beta = tf.compat.v1.get_variable(
name='beta',
shape=[32],
initializer=tf.compat.v1.random_normal_initializer())
gamma = tf.compat.v1.get_variable(
name='gamma',
shape=[32],
initializer=tf.compat.v1.random_normal_initializer())
conv1 = tf.nn.conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="SAME")
conv_bias = tf.nn.bias_add(conv1, conv_bias)
normed = tf.compat.v1.layers.batch_normalization(conv_bias)
with tf.compat.v1.Session() as sess:
sess.run(tf.compat.v1.global_variables_initializer())
output_graph_def = graph_util.convert_variables_to_constants(
sess=sess,
input_graph_def=sess.graph_def,
output_node_names=[normed.name.split(':')[0]])
output_graph_def = QuantizeGraphHelper.remove_training_nodes(
output_graph_def, protected_nodes=[normed.name.split(':')[0]])
graph_def = copy.deepcopy(output_graph_def)
fold_graph_def = FoldBatchNormNodesOptimizer(
output_graph_def).do_transformation()
def test_fold_output_values(self):
input_data = np.random.randn(1, 224, 224, 3)
graph = tf.compat.v1.Graph()
fold_graph = tf.compat.v1.Graph()
with graph.as_default():
tf.compat.v1.import_graph_def(self.graph_def, name='')
with tf.compat.v1.Session(graph=graph) as sess:
sess.run(tf.compat.v1.global_variables_initializer())
x = graph.get_tensor_by_name('input:0')
normed = graph.get_tensor_by_name(
'batch_normalization/FusedBatchNormV3:0')
y = sess.run(normed, feed_dict={x: input_data})
with fold_graph.as_default():
tf.compat.v1.import_graph_def(self.fold_graph_def, name='')
with tf.compat.v1.Session(graph=fold_graph) as sess:
sess.run(tf.compat.v1.global_variables_initializer())
x = fold_graph.get_tensor_by_name('input:0')
normed = fold_graph.get_tensor_by_name(
'batch_normalization/FusedBatchNormV3:0')
y_fold = sess.run(normed, feed_dict={x: input_data})
assert np.allclose(y, y_fold, rtol=1e-05, atol=1e-05)
def test_do_transform(self):
for node in self.fold_graph_def.node:
assert node.op not in ["FusedBatchNormV3"]
def test_parse_pb_contains_share_nodes(self):
original_graphdef = read_graph(
os.path.join(self.unzipped_folder_name,
"frozen_inference_graph.pb"))
copied_graphdef = copy.deepcopy(original_graphdef)
parsed_graphdef = SplitSharedInputOptimizer(
original_graphdef).do_transformation()
legacy_graphdef = QuantizeGraphHelper.split_shared_inputs(
copied_graphdef)
self.assertGreater(len(parsed_graphdef.node),
len(original_graphdef.node))
self.assertEqual(len(legacy_graphdef.node), len(parsed_graphdef.node))
def test_conv_add_relu(self):
x = tf.compat.v1.placeholder(tf.float32, [1, 224, 224, 3],
name="input")
if tf.version.VERSION <= '2.1.0':
x = tf.nn.relu(x)
conv_weights = tf.compat.v1.get_variable(
"weight", [3, 3, 3, 32],
initializer=tf.compat.v1.random_normal_initializer())
conv_bias = tf.compat.v1.get_variable(
"bias", [32], initializer=tf.compat.v1.random_normal_initializer())
conv1 = tf.nn.conv2d(x,
conv_weights,
strides=[1, 1, 1, 1],
padding="SAME")
conv_bias = tf.math.add(conv1, conv_bias)
relu = tf.nn.relu(conv_bias, name='Relu_1')
op_wise_sequences = TensorflowQuery(local_config_file=os.path.join(
os.path.dirname(__file__),
"../lpot/adaptor/tensorflow.yaml")).get_eightbit_patterns()
with tf.compat.v1.Session() as sess:
sess.run(tf.compat.v1.global_variables_initializer())
output_graph_def = graph_util.convert_variables_to_constants(
sess=sess,
input_graph_def=sess.graph_def,
output_node_names=[relu.name.split(':')[0]])
output_graph_def = QuantizeGraphHelper.remove_training_nodes(
output_graph_def, protected_nodes=[relu.name.split(':')[0]])
outputs = [relu.name.split(':')[0]]
op_wise_config = {
"Conv2D": (False, 'minmax', False, 7.0),
}
fold_graph_def = QuantizeGraphForIntel(output_graph_def, outputs,
op_wise_config,
op_wise_sequences,
'cpu').do_transform()
found_QuantizedConv2DWithBiasAndRelu = False
for i in fold_graph_def.node:
if i.op == 'QuantizedConv2DWithBiasAndRelu':
found_QuantizedConv2DWithBiasAndRelu = True
break
self.assertEqual(found_QuantizedConv2DWithBiasAndRelu, True)
def test_data_pipeline(self):
tf.compat.v1.disable_eager_execution()
raw_dataset = np.ones([100, 224, 224, 3], dtype=np.float32)
tf_dataset = tf.compat.v1.data.Dataset.from_tensor_slices(raw_dataset)
tf_dataset = tf_dataset.batch(1)
ds_iterator = tf_dataset.make_initializable_iterator()
iter_tensors = ds_iterator.get_next()
conv_weights = tf.compat.v1.get_variable(
"weight", [3, 3, 3, 32],
initializer=tf.compat.v1.random_normal_initializer())
conv_bias = tf.compat.v1.get_variable(
"bias", [32], initializer=tf.compat.v1.random_normal_initializer())
conv1 = tf.nn.conv2d(iter_tensors,
conv_weights,
strides=[1, 1, 1, 1],
padding="SAME")
conv_bias = tf.math.add(conv1, conv_bias)
relu = tf.nn.relu(conv_bias, name='Relu_1')
output_names = [relu.name.split(':')[0], 'MakeIterator']
with tf.compat.v1.Session() as sess:
sess.run(tf.compat.v1.global_variables_initializer())
output_graph_def = graph_util.convert_variables_to_constants(
sess=sess,
input_graph_def=sess.graph_def,
output_node_names=output_names)
output_graph_def = QuantizeGraphHelper.remove_training_nodes(
output_graph_def, protected_nodes=output_names)
graph = tf.Graph()
with graph.as_default():
tf.import_graph_def(output_graph_def, name='')
print('graph has been generated....')
iter_op = graph.get_operation_by_name('MakeIterator')
output_tensor = get_tensor_by_name(graph, output_names[0])
sess = tf.compat.v1.Session(graph=graph)
iterator_sess_run(sess, iter_op, \
feed_dict={}, output_tensor=output_tensor)
def test_remove_training_nodes_save_last_identity(self):
tf.compat.v1.disable_eager_execution()
input_constant_name = "input_constant"
relu_name = "relu"
float_graph_def = graph_pb2.GraphDef()
input_constant = QuantizeGraphHelper.create_constant_node(
input_constant_name,
value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
dtype=dtypes.float32,
shape=[1, 2, 6, 1])
float_graph_def.node.extend([input_constant])
relu_node = QuantizeGraphHelper.create_node("Relu", relu_name,
[input_constant_name])
QuantizeGraphHelper.set_attr_dtype(relu_node, "T", dtypes.float32)
float_graph_def.node.extend([relu_node])
b_constant_name = "b_constant"
mat_mul_name = "mat_mul"
identity_name = "identity"
b_constant = QuantizeGraphHelper.create_constant_node(
b_constant_name, value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], dtype=dtypes.float32, shape=[2, 6])
float_graph_def.node.extend([b_constant])
mat_mul_node = QuantizeGraphHelper.create_node("MatMul", mat_mul_name,
[relu_name, b_constant_name])
QuantizeGraphHelper.set_attr_dtype(mat_mul_node, "T", dtypes.float32)
QuantizeGraphHelper.set_attr_bool(mat_mul_node, "transpose_a", False)
QuantizeGraphHelper.set_attr_bool(mat_mul_node, "transpose_b", False)
float_graph_def.node.extend([mat_mul_node])
identity_node = QuantizeGraphHelper.create_node("Identity", identity_name,
[mat_mul_name])
float_graph_def.node.extend([identity_node])
bias_add_name = "bias_add"
offset_constant_name = "offset_constant"
offset_constant = QuantizeGraphHelper.create_constant_node(
offset_constant_name,
value=[1, 2, 3, 4, 5, 6],
dtype=dtypes.float32,
shape=[6])
float_graph_def.node.extend([offset_constant])
bias_add_node = QuantizeGraphHelper.create_node(
"BiasAdd", bias_add_name, [identity_name, offset_constant_name])
QuantizeGraphHelper.set_attr_dtype(bias_add_node, "T", dtypes.float32)
float_graph_def.node.extend([bias_add_node])
post_relu_name = "post_relu"
post_relu_node = QuantizeGraphHelper.create_node("Relu", post_relu_name,
[bias_add_name])
float_graph_def.node.extend([post_relu_node])
last_identity_node_name = 'last_identity'
last_identity_node = QuantizeGraphHelper.create_node("Identity", last_identity_node_name,
[post_relu_name])
float_graph_def.node.extend([last_identity_node])
post_graph = QuantizeGraphHelper().remove_training_nodes(
float_graph_def, protected_nodes=[last_identity_node_name])
found_identity_node_name = []
for i in post_graph.node:
if i.op == 'Identity':
found_identity_node_name.append(i.name)
break
self.assertEqual(found_identity_node_name[0], 'last_identity')
def test_matmul_biasadd_relu_fusion(self):
tf.compat.v1.disable_eager_execution()
input_constant_name = "input_constant"
relu_name = "relu"
float_graph_def = graph_pb2.GraphDef()
input_constant = QuantizeGraphHelper.create_constant_node(
input_constant_name,
value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
dtype=dtypes.float32,
shape=[1, 2, 6, 1])
float_graph_def.node.extend([input_constant])
relu_node = QuantizeGraphHelper.create_node("Relu", relu_name,
[input_constant_name])
QuantizeGraphHelper.set_attr_dtype(relu_node, "T", dtypes.float32)
float_graph_def.node.extend([relu_node])
b_constant_name = "b_constant"
mat_mul_name = "mat_mul"
b_constant = QuantizeGraphHelper.create_constant_node(
b_constant_name,
value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
dtype=dtypes.float32,
shape=[2, 6])
float_graph_def.node.extend([b_constant])
mat_mul_node = QuantizeGraphHelper.create_node(
"MatMul", mat_mul_name, [relu_name, b_constant_name])
QuantizeGraphHelper.set_attr_dtype(mat_mul_node, "T", dtypes.float32)
QuantizeGraphHelper.set_attr_bool(mat_mul_node, "transpose_a", False)
QuantizeGraphHelper.set_attr_bool(mat_mul_node, "transpose_b", False)
float_graph_def.node.extend([mat_mul_node])
bias_add_name = "bias_add"
offset_constant_name = "offset_constant"
offset_constant = QuantizeGraphHelper.create_constant_node(
offset_constant_name,
value=[1, 2, 3, 4, 5, 6],
dtype=dtypes.float32,
shape=[6])
float_graph_def.node.extend([offset_constant])
bias_add_node = QuantizeGraphHelper.create_node(
"BiasAdd", bias_add_name, [mat_mul_name, offset_constant_name])
QuantizeGraphHelper.set_attr_dtype(bias_add_node, "T", dtypes.float32)
float_graph_def.node.extend([bias_add_node])
post_relu_name = "post_relu"
post_relu_node = QuantizeGraphHelper.create_node(
"Relu", post_relu_name, [bias_add_name])
float_graph_def.node.extend([post_relu_node])
worker = FuseNodeStartWithMatmul(float_graph_def, mat_mul_name, False,
mat_mul_name, 'cpu', False)
output_graph = worker.apply_the_transform()
found_quantized_matmul = False
for i in output_graph.node:
if i.op == 'QuantizedMatMulWithBiasAndRelu':
found_quantized_matmul = True
break
self.assertEqual(found_quantized_matmul, True)
def test_graph_fold_bn(self):
input_constant_name = "input_constant"
relu_name = "relu"
float_graph_def = graph_pb2.GraphDef()
input_constant = QuantizeGraphHelper.create_constant_node(
input_constant_name,
value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
dtype=dtypes.float32,
shape=[1, 2, 6, 1])
float_graph_def.node.extend([input_constant])
relu_node = QuantizeGraphHelper.create_node("Relu", relu_name,
[input_constant_name])
QuantizeGraphHelper.set_attr_dtype(relu_node, "T", dtypes.float32)
float_graph_def.node.extend([relu_node])
b_constant_name = "b_constant"
conv2d_name = "conv2d_1"
b_constant = QuantizeGraphHelper.create_constant_node(
b_constant_name,
value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
dtype=dtypes.float32,
shape=[1, 2, 3, 4])
float_graph_def.node.extend([b_constant])
conv2d_node = QuantizeGraphHelper.create_node(
"Conv2D", conv2d_name, [relu_name, b_constant_name])
QuantizeGraphHelper.set_attr_dtype(conv2d_node, "T", dtypes.float32)
float_graph_def.node.extend([conv2d_node])
bias_add_name = "bias_add"
offset_constant_name = "offset_constant"
offset_constant = QuantizeGraphHelper.create_constant_node(
offset_constant_name,
value=[1, 2, 3, 4, 5, 6],
dtype=dtypes.float32,
shape=[6])
float_graph_def.node.extend([offset_constant])
bias_add_node = QuantizeGraphHelper.create_node(
"BiasAdd", bias_add_name, [conv2d_name, offset_constant_name])
QuantizeGraphHelper.set_attr_dtype(bias_add_node, "T", dtypes.float32)
float_graph_def.node.extend([bias_add_node])
bn_scale_name = 'bn_scale'
bn_scale_node = QuantizeGraphHelper.create_constant_node(
bn_scale_name,
value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
dtype=dtypes.float32,
shape=[12, 1])
bn_offset_name = 'bn_offset'
bn_offset_node = QuantizeGraphHelper.create_constant_node(
bn_offset_name,
value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
dtype=dtypes.float32,
shape=[12, 1])
bn_mean_name = 'bn_mean'
bn_mean_node = QuantizeGraphHelper.create_constant_node(
bn_mean_name, value=[
1,
2,
], dtype=dtypes.float32, shape=[
2,
])
bn_var_name = 'bn_var'
bn_var_node = QuantizeGraphHelper.create_constant_node(
bn_var_name, value=[], dtype=dtypes.float32, shape=[0])
fused_bn_node_name = 'bn'
fused_bn_node = QuantizeGraphHelper.create_node(
"FusedBatchNormV3", fused_bn_node_name, [
bias_add_name, bn_scale_name, bn_offset_name, bn_mean_name,
bn_var_name
])
QuantizeGraphHelper.set_attr_dtype(fused_bn_node, "T", dtypes.float32)
QuantizeGraphHelper.set_attr_dtype(fused_bn_node, "U", dtypes.float32)
float_graph_def.node.extend([
fused_bn_node, bn_scale_node, bn_offset_node, bn_mean_node,
bn_var_node
])
post_relu_name = "post_relu"
post_relu_node = QuantizeGraphHelper.create_node(
"Relu", post_relu_name, [fused_bn_node_name])
float_graph_def.node.extend([post_relu_node])
post_graph = FoldBatchNormNodesOptimizer(
float_graph_def).do_transformation()
bn_not_fused = False
for i in post_graph.node:
if i.op == 'FusedBatchNormV3':
bn_not_fused = True
break
self.assertEqual(bn_not_fused, True)
def test_insert_logging_on_ordinary_op(self):
tf.compat.v1.disable_eager_execution()
input_constant_name = "input_constant"
relu_name = "relu"
float_graph_def = graph_pb2.GraphDef()
input_constant = QuantizeGraphHelper.create_constant_node(
input_constant_name,
value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
dtype=dtypes.float32,
shape=[1, 2, 6, 1])
float_graph_def.node.extend([input_constant])
relu_node = QuantizeGraphHelper.create_node("Relu", relu_name, [input_constant_name])
QuantizeGraphHelper.set_attr_dtype(relu_node, "T", dtypes.float32)
float_graph_def.node.extend([relu_node])
b_constant_name = "b_constant"
mat_mul_name = "mat_mul"
identity_name = "identity"
b_constant = QuantizeGraphHelper.create_constant_node(
b_constant_name,
value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
dtype=dtypes.float32,
shape=[2, 6])
float_graph_def.node.extend([b_constant])
mat_mul_node = QuantizeGraphHelper.create_node("MatMul", mat_mul_name,
[relu_name, b_constant_name])
QuantizeGraphHelper.set_attr_dtype(mat_mul_node, "T", dtypes.float32)
QuantizeGraphHelper.set_attr_bool(mat_mul_node, "transpose_a", False)
QuantizeGraphHelper.set_attr_bool(mat_mul_node, "transpose_b", False)
float_graph_def.node.extend([mat_mul_node])
identity_node = QuantizeGraphHelper.create_node("Identity", identity_name, [mat_mul_name])
float_graph_def.node.extend([identity_node])
bias_add_name = "bias_add"
offset_constant_name = "offset_constant"
offset_constant = QuantizeGraphHelper.create_constant_node(offset_constant_name,
value=[1, 2, 3, 4, 5, 6],
dtype=dtypes.float32,
shape=[6])
float_graph_def.node.extend([offset_constant])
bias_add_node = QuantizeGraphHelper.create_node("BiasAdd", bias_add_name,
[identity_name, offset_constant_name])
QuantizeGraphHelper.set_attr_dtype(bias_add_node, "T", dtypes.float32)
float_graph_def.node.extend([bias_add_node])
post_relu_name = "post_relu"
post_relu_node = QuantizeGraphHelper.create_node("Relu", post_relu_name, [bias_add_name])
float_graph_def.node.extend([post_relu_node])
last_max_node_name = 'Max'
last_max_node = QuantizeGraphHelper.create_node("Max", last_max_node_name,
[post_relu_name])
float_graph_def.node.extend([last_max_node])
post_graph = InsertLoggingTransformer(float_graph_def,
target_op_types=['Max'],
message="__max:").do_transformation()
has_print_op = False
for node in post_graph.node:
if node.op == 'Print':
has_print_op = True
break
self.assertEqual(has_print_op, False)
def test_graph_cse(self):
tf.compat.v1.disable_eager_execution()
input_constant_name = "input_constant"
relu_name = "relu"
float_graph_def = graph_pb2.GraphDef()
input_constant = QuantizeGraphHelper.create_constant_node(
input_constant_name,
value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
dtype=dtypes.float32,
shape=[1, 2, 6, 1])
float_graph_def.node.extend([input_constant])
relu_node = QuantizeGraphHelper.create_node("Relu", relu_name,
[input_constant_name])
QuantizeGraphHelper.set_attr_dtype(relu_node, "T", dtypes.float32)
float_graph_def.node.extend([relu_node])
b_constant_name = "b_constant"
mat_mul_name = "mat_mul"
b_constant = QuantizeGraphHelper.create_constant_node(
b_constant_name,
value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
dtype=dtypes.float32,
shape=[2, 6])
float_graph_def.node.extend([b_constant])
mat_mul_node = QuantizeGraphHelper.create_node(
"MatMul", mat_mul_name, [relu_name, b_constant_name])
QuantizeGraphHelper.set_attr_dtype(mat_mul_node, "T", dtypes.float32)
QuantizeGraphHelper.set_attr_bool(mat_mul_node, "transpose_a", False)
QuantizeGraphHelper.set_attr_bool(mat_mul_node, "transpose_b", False)
float_graph_def.node.extend([mat_mul_node])
bias_add_name = "bias_add"
offset_constant_name = "offset_constant"
offset_constant = QuantizeGraphHelper.create_constant_node(
offset_constant_name,
value=[1, 2, 3, 4, 5, 6],
dtype=dtypes.float32,
shape=[6])
float_graph_def.node.extend([offset_constant])
bias_add_node = QuantizeGraphHelper.create_node(
"BiasAdd", bias_add_name, [mat_mul_name, offset_constant_name])
QuantizeGraphHelper.set_attr_dtype(bias_add_node, "T", dtypes.float32)
float_graph_def.node.extend([bias_add_node])
post_relu_name = "post_relu"
post_relu_node = QuantizeGraphHelper.create_node(
"Relu", post_relu_name, [bias_add_name])
float_graph_def.node.extend([post_relu_node])
last_identity_node_name = 'last_identity'
last_identity_node = QuantizeGraphHelper.create_node(
"Identity", last_identity_node_name, [post_relu_name])
float_graph_def.node.extend([last_identity_node])
analyzer = GraphAnalyzer()
analyzer.graph = float_graph_def
analyzer.parse_graph()
res = analyzer.query_fusion_pattern_nodes([['MatMul'], ("BiasAdd"),
("Relu")])
self.assertEqual(3, len(res[0][-1]))
def test_graph_cse(self):
input_constant_name = "input_constant"
relu_name = "relu"
float_graph_def = graph_pb2.GraphDef()
input_constant = QuantizeGraphHelper.create_constant_node(
input_constant_name,
value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
dtype=dtypes.float32,
shape=[1, 2, 6, 1])
float_graph_def.node.extend([input_constant])
relu_node = QuantizeGraphHelper.create_node("Relu", relu_name,
[input_constant_name])
QuantizeGraphHelper.set_attr_dtype(relu_node, "T", dtypes.float32)
float_graph_def.node.extend([relu_node])
b_constant_name = "b_constant"
mat_mul_name = "mat_mul"
identity_name = "identity"
b_constant = QuantizeGraphHelper.create_constant_node(
b_constant_name,
value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
dtype=dtypes.float32,
shape=[2, 6])
float_graph_def.node.extend([b_constant])
mat_mul_node = QuantizeGraphHelper.create_node(
"MatMul", mat_mul_name, [relu_name, b_constant_name])
QuantizeGraphHelper.set_attr_dtype(mat_mul_node, "T", dtypes.float32)
QuantizeGraphHelper.set_attr_bool(mat_mul_node, "transpose_a", False)
QuantizeGraphHelper.set_attr_bool(mat_mul_node, "transpose_b", False)
float_graph_def.node.extend([mat_mul_node])
identity_node = QuantizeGraphHelper.create_node(
"Identity", identity_name, [mat_mul_name])
float_graph_def.node.extend([identity_node])
bias_add_name = "bias_add"
offset_constant_name = "offset_constant"
offset_constant = QuantizeGraphHelper.create_constant_node(
offset_constant_name,
value=[1, 2, 3, 4, 5, 6],
dtype=dtypes.float32,
shape=[6])
float_graph_def.node.extend([offset_constant])
bias_add_node = QuantizeGraphHelper.create_node(
"BiasAdd", bias_add_name, [identity_name, offset_constant_name])
QuantizeGraphHelper.set_attr_dtype(bias_add_node, "T", dtypes.float32)
float_graph_def.node.extend([bias_add_node])
post_relu_name = "post_relu"
post_relu_node = QuantizeGraphHelper.create_node(
"Relu", post_relu_name, [bias_add_name])
float_graph_def.node.extend([post_relu_node])
last_identity_node_name = 'last_identity'
last_identity_node = QuantizeGraphHelper.create_node(
"Identity", last_identity_node_name, [post_relu_name])
float_graph_def.node.extend([last_identity_node])
left_relu_name = "final_left_relu"
left_relu_node = QuantizeGraphHelper.create_node(
"Relu", left_relu_name, [last_identity_node_name])
float_graph_def.node.extend([left_relu_node])
right_relu_name = "final_right_relu"
right_relu_node = QuantizeGraphHelper.create_node(
"Relu", right_relu_name, [last_identity_node_name])
float_graph_def.node.extend([right_relu_node])
cse_left_node_name = "cse_left_node"
cse_left_node = QuantizeGraphHelper.create_node(
"Identity", cse_left_node_name, [left_relu_name])
float_graph_def.node.extend([cse_left_node])
cse_right_node_name = "cse_right_node"
cse_right_node = QuantizeGraphHelper.create_node(
"Identity", cse_right_node_name, [right_relu_name])
float_graph_def.node.extend([cse_right_node])
# post_graph = QuantizeGraphHelper().graph_cse_optimization (
# float_graph_def)
post_graph = GraphCseOptimizer(float_graph_def).do_transformation()
right_relu_optimized_flag = True
for i in post_graph.node:
if i.name == right_relu_name:
right_relu_optimized_flag = False
break
self.assertEqual(right_relu_optimized_flag, True)
def test_scale_propagation(self):
"""Test scale propagation for below pattern
requantize + quantizedavgpool+ quantized conv2d + requantize.
"""
tf.compat.v1.disable_eager_execution()
input_constant_name = "input_constant"
relu_name = "relu"
float_graph_def = graph_pb2.GraphDef()
input_constant = QuantizeGraphHelper.create_constant_node(
input_constant_name,
value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
dtype=dtypes.float32,
shape=[1, 2, 6, 1])
float_graph_def.node.extend([input_constant])
requantize_min_name = "requantize_min_const"
requantize_min = QuantizeGraphHelper.create_constant_node(
requantize_min_name,
value=1,
dtype=dtypes.float32,
)
float_graph_def.node.extend([requantize_min])
requantize_max_name = "requantize_max_const"
requantize_max = QuantizeGraphHelper.create_constant_node(
requantize_max_name,
value=5,
dtype=dtypes.float32,
)
float_graph_def.node.extend([requantize_max])
relu_node = QuantizeGraphHelper.create_node("Requantize", relu_name, [
input_constant_name, input_constant_name + ':1',
input_constant_name + ':2', requantize_min_name,
requantize_max_name
])
QuantizeGraphHelper.set_attr_dtype(relu_node, "Tinput", dtypes.qint32)
QuantizeGraphHelper.set_attr_dtype(relu_node, "out_type",
dtypes.quint8)
float_graph_def.node.extend([relu_node])
b_constant_name = "b_constant"
mat_mul_name = "mat_mul"
b_constant = QuantizeGraphHelper.create_constant_node(
b_constant_name, value=[0], dtype=dtypes.float32, shape=[
1,
])
float_graph_def.node.extend([b_constant])
avgpool_max_constant_name = "avgpool_max_constant"
mat_mul_name = "mat_mul"
avgpool_max = QuantizeGraphHelper.create_constant_node(
avgpool_max_constant_name,
value=[10],
dtype=dtypes.float32,
shape=[
1,
])
float_graph_def.node.extend([avgpool_max])
quantized_avgpool = QuantizeGraphHelper.create_node(
"QuantizedAvgPool", mat_mul_name,
[relu_name, b_constant_name, avgpool_max_constant_name])
QuantizeGraphHelper.set_attr_dtype(quantized_avgpool, "T",
dtypes.float32)
float_graph_def.node.extend([quantized_avgpool])
bias_add_name = "bias_add"
offset_constant_name = "offset_constant"
offset_constant = QuantizeGraphHelper.create_constant_node(
offset_constant_name,
value=[1, 2, 3, 4, 5, 6],
dtype=dtypes.float32,
shape=[6])
float_graph_def.node.extend([offset_constant])
bias_add_node = QuantizeGraphHelper.create_node(
"QuantizedConv2DWithBiasAndRelu", bias_add_name,
[mat_mul_name, offset_constant_name])
QuantizeGraphHelper.set_attr_dtype(bias_add_node, "T", dtypes.float32)
float_graph_def.node.extend([bias_add_node])
post_min_value = -1
post_max_value = 7
post_requantize_min_name = "post_requantize_min_const"
post_requantize_min = QuantizeGraphHelper.create_constant_node(
post_requantize_min_name,
value=post_min_value,
dtype=dtypes.float32,
)
float_graph_def.node.extend([post_requantize_min])
post_requantize_max_name = "post_requantize_max_const"
post_requantize_max = QuantizeGraphHelper.create_constant_node(
post_requantize_max_name,
value=post_max_value,
dtype=dtypes.float32,
)
float_graph_def.node.extend([post_requantize_max])
post_requantize_name = "post_requantize"
post_requantize_node = QuantizeGraphHelper.create_node(
"Requantize", post_requantize_name, [
bias_add_name, bias_add_name + ':1', bias_add_name + ':2',
post_requantize_min_name, post_requantize_max_name
])
float_graph_def.node.extend([post_requantize_node])
optimized_graph = ScaleProPagationTransformer(
float_graph_def).do_transformation()
update_min_value = None
update_max_value = None
for node in optimized_graph.node:
if node.name == 'relu_cac_requantize_min_value':
update_min_value = node.attr['value'].tensor.float_val[0]
if node.name == 'relu_cac_requantize_max_value':
update_max_value = node.attr['value'].tensor.float_val[0]
self.assertEqual(update_min_value, post_min_value)
self.assertEqual(update_max_value, post_max_value)