def test_int32_specific_data_type_range_infer(self):
# import tensorflow to use TF data types
import tensorflow as tf
graph = build_graph(
nodes_attributes, edges, {
'start': {
'value': np.array([1])
},
'limit': {
'value': np.array([5])
},
'delta': {
'value': np.array([1])
},
'range': {
'pb': FakeParam('attr',
dict(type=FakeParam('type', tf.int32)))
},
})
range_node = Node(graph, 'range')
tf_range_infer(range_node)
exp_value = np.array([1, 2, 3, 4], dtype=np.int32)
out_value = graph.node['output']['value']
self.assertTrue(exp_value.dtype == out_value.dtype)
self.assertTrue(np.array_equal(exp_value.shape, out_value.shape))
self.assertTrue(np.array_equal(exp_value, out_value))
def test_bn(self):
bn_pb = FakeBNProtoLayer(FakeParam('eps', 0.0001))
mean = [1, 2.5, 3]
var = [0.5, 0.1, 1.2]
scale = [2.3, 3.4, 4.5]
shift = [0.8, 0.6, 0.4]
bn_bin = FakeBNBinLayer([
FakeParam('data', mean),
FakeParam('data', var),
FakeParam('data', scale),
FakeParam('data', shift)
])
nodes = {
'node_1': {
'kind': 'op',
'type': 'Identity',
'op': 'Placeholder'
},
'bn': {
'type': 'BN',
'kind': 'op',
'op': 'BN',
'pb': bn_pb,
'model_pb': bn_bin
},
'node_2': {
'kind': 'op',
'type': 'Identity',
'op': 'Placeholder'
}
}
edges = [('node_1', 'bn', {'in': 0}), ('bn', 'node_2', {'in': 0})]
graph = build_graph_with_edge_attrs(nodes, edges)
node = Node(graph, 'bn')
replacer = BNToScaleShift()
replacer.replace_op(graph, node)
scale_node = [
node for node, attrs in list(graph.nodes(data=True))
if attrs['type'] == 'ScaleShift'
]
self.assertEqual(len(scale_node), 1)
scale_ref = np.array([1.11796412, 3.2272172, 4.74282367])
shift_ref = np.array([-2.07131747, -10.87253847, -20.14270653])
for i in range(len(mean)):
self.assertAlmostEqual(graph.node[scale_node[0]]['scale'][i],
scale_ref[i])
self.assertAlmostEqual(graph.node[scale_node[0]]['bias'][i],
shift_ref[i])
def test_automatic_data_type_range_infer(self):
graph = build_graph(
nodes_attributes, edges, {
'start': {
'value': np.array([2], dtype=np.float32)
},
'limit': {
'value': np.array([5])
},
'delta': {
'value': np.array([1])
},
'range': {
'pb': FakeParam('attr', dict())
},
})
range_node = Node(graph, 'range')
tf_range_infer(range_node)
exp_value = np.array([2.0, 3.0, 4.0], dtype=np.float32)
out_value = graph.node['output']['value']
self.assertTrue(exp_value.dtype == out_value.dtype)
self.assertTrue(np.array_equal(exp_value.shape, out_value.shape))
self.assertTrue(np.array_equal(exp_value, out_value))
def test_input_ext(self, single_output_infer_mock):
single_output_infer_mock.return_value = {}
shape = [FakeParam('dim', 1)]
res = input_ext(FakeProtoLayer(shape), None)
exp_res = {'op': 'Placeholder', 'shape': [1], 'infer': None}
for i in exp_res.keys():
if i == 'infer':
res['infer'](None)
self.assertTrue(single_output_infer_mock.called)
def test_bn(self):
bn_pb = FakeBNProtoLayer(FakeParam('eps', 0.0001))
mean = [1, 2.5, 3]
var = [0.5, 0.1, 1.2]
scale = [2.3, 3.4, 4.5]
shift = [0.8, 0.6, 0.4]
bn_bin = FakeBNBinLayer([FakeParam('data', mean),
FakeParam('data', var),
FakeParam('data', scale),
FakeParam('data', shift)])
nodes = [
('input', {'kind': 'op', 'type': 'Identity', 'op': 'Identity'}),
('bn', {'type': 'BN', 'kind': 'op', 'op': 'BN', 'pb': bn_pb, 'model_pb': bn_bin}),
('output', {'kind': 'op', 'type': 'Identity', 'op': 'Identity'}),
]
edges = [
('input', 'bn', {'in': 0, 'out': 0}),
('bn', 'output', {'in': 0, 'out': 0}),
]
graph = build_graph_with_attrs(nodes, edges)
node = Node(graph, 'bn')
graph.stage = 'front'
BNToScaleShift().find_and_replace_pattern(graph)
ref_nodes = {
'input': {'kind': 'op', 'type': 'Identity', 'op': 'Identity'},
'scale': {'kind': 'op', 'type': 'Const', 'op': 'Const',
'value': np.array([1.11796412, 3.2272172, 4.74282367])},
'shift': {'kind': 'op', 'type': 'Const', 'op': 'Const',
'value': np.array([-2.07131747, -10.87253847, -20.14270653])},
'ss': {'type': 'ScaleShift', 'kind': 'op', 'op': 'ScaleShift'},
'output': {'kind': 'op', 'type': 'Identity', 'op': 'Identity'},
}
ref_edges = [
('input', 'ss', {'in': 0, 'out': 0}),
('scale', 'ss', {'in': 1, 'out': 0}),
('shift', 'ss', {'in': 2, 'out': 0}),
('ss', 'output', {'in': 0, 'out': 0}),
]
ref_graph = build_graph_with_edge_attrs(ref_nodes, ref_edges)
(flag, resp) = compare_graphs(graph, ref_graph, 'input', check_op_attrs=True)
self.assertTrue(flag, resp)
def test_relu_ext(self):
params = {
'negative_slope': 0.1,
}
res = relu_ext(FakeParam('relu_param', FakeMultiParam(params)), None)
exp_res = {
'negative_slope': 0.1,
'infer': copy_shape_infer,
}
exp_res.update(layout_attrs())
for i in exp_res.keys():
if i == 'negative_slope':
self.assertEqual(res[i], exp_res[i])
else:
np.testing.assert_array_equal(res[i], exp_res[i])
def test_non_constant_delta_range_infer(self):
graph = build_graph(
nodes_attributes, edges, {
'start': {
'value': np.array([1])
},
'limit': {
'value': np.array([10])
},
'delta': {},
'range': {
'pb': FakeParam('attr', dict())
},
})
range_node = Node(graph, 'range')
tf_range_infer(range_node)
out_value = graph.node['output']['value']
self.assertIsNone(out_value)
def __init__(self, axis):
self.concat_param = FakeParam('axis', axis)
def __init__(self, shape):
self.input_param = FakeParam('shape', shape)
def __init__(self, eps):
self.batch_norm_param = FakeParam('eps', eps)
def test_get_list_from_container_list_match_empty(self):
res = get_list_from_container(FakeParam('prop', []), 'prop', int)
self.assertEqual(res, [])
def test_get_list_from_container_simple_type_match(self):
res = get_list_from_container(FakeParam('prop', 10), 'prop', int)
self.assertEqual(res, [10])
def test_get_list_from_container_no_existing_param(self):
res = get_list_from_container(FakeParam("p", "1"), 'prop', int)
self.assertEqual(res, [])
def ListFields(self):
keys = []
for k in self.dict_values.keys():
keys.append([FakeParam('name', k)])
return keys
