def test_broadcast(self, data, target_shape, axes_mapping=None, mode='numpy', ref_out=None, test_raising=False):
if ref_out is not None:
input = valued_const_with_data('data', int64_array(data))
else:
input = shaped_data('data', int64_array(data))
nodes = {
**input,
**valued_const_with_data('target_shape', int64_array(target_shape)),
**regular_op_with_empty_data('broadcast', {'op': 'Broadcast', 'mode': mode}),
}
edges = [('data', 'broadcast'),
('target_shape', 'broadcast'),
('broadcast', 'broadcast_d')]
if axes_mapping is not None:
nodes.update(**valued_const_with_data('axes_mapping', int64_array(axes_mapping)))
edges.append(('axes_mapping', 'broadcast'))
graph = build_graph(nodes, edges)
broadcast_node = Node(graph, 'broadcast')
if test_raising:
self.assertRaises(AssertionError, Broadcast.infer, broadcast_node)
return
Broadcast.infer(broadcast_node)
if ref_out is not None:
self.assertTrue(np.array_equal(broadcast_node.out_node().value, np.array(ref_out)))
else:
self.assertTrue(np.array_equal(broadcast_node.out_node().shape, np.array(target_shape)))
def test_broadcast_dynamic(self, data, target_shape_shape, mode='numpy', ref_out_shape=None, test_raising=False):
nodes = {
**shaped_data('data', int64_array(data)),
**shaped_data('target_shape', int64_array(target_shape_shape)),
**regular_op_with_empty_data('broadcast', {'op': 'Broadcast', 'mode': mode}),
}
edges = [('data', 'broadcast'),
('target_shape', 'broadcast'),
('broadcast', 'broadcast_d')]
graph = build_graph(nodes, edges)
broadcast_node = Node(graph, 'broadcast')
if test_raising:
self.assertRaises(AssertionError, Broadcast.infer, broadcast_node)
return
Broadcast.infer(broadcast_node)
self.assertTrue(np.array_equal(broadcast_node.out_node().shape, ref_out_shape))
def test_slice_infer(self, inp_value, inp_shape, starts, ends, axes, steps,
expected_value, expected_shape):
if inp_value is None:
input_node = shaped_data('data_1', int64_array(inp_shape))
else:
input_node = valued_data('data_1', int64_array(inp_value))
if inp_value is not None and inp_shape is not None:
assert np.array_equal(np.array(inp_value).shape, inp_shape)
def convert_args(val, name=''):
if val is not None:
return valued_const_with_data(name, int64_array(val))
else:
return shaped_const_with_data(name, [0]) #fake shape
starts = convert_args(starts, 'starts')
ends = convert_args(ends, 'ends')
axes = convert_args(axes, 'axes')
steps = convert_args(steps, 'steps')
if expected_shape is not None:
expected_shape = shape_array(expected_shape)
nodes = {
**input_node,
**regular_op_with_empty_data('slice', {'op': 'Slice'}),
**starts,
**ends,
**axes,
**steps,
}
graph = build_graph(
nodes,
[('data_1', 'slice'), *connect('starts', '1:slice'),
*connect('ends', '2:slice'), *connect('axes', '3:slice'),
*connect('steps', '4:slice'), *connect('slice', 'slice_d')])
graph.stage = 'middle'
slice_node = Node(graph, 'slice')
Slice.infer(slice_node)
if expected_value is not None:
self.assertTrue(
strict_compare_tensors(slice_node.out_node().value,
expected_value))
self.assertTrue(
strict_compare_tensors(slice_node.out_node().shape,
expected_shape))
def create_fake_quantize_net(self, il, ih, num_bits, narrow_range, nudged_il, nudged_ih, expected_step, ir_version, use_new_frontend):
# original tf model
import tensorflow as tf
tf.compat.v1.reset_default_graph()
with tf.compat.v1.Session() as sess:
data = tf.compat.v1.placeholder(tf.float32, [11], 'parameter')
input_min = tf.constant(il, name='input_min')
input_max = tf.constant(ih, name='input_max')
tf.quantization.fake_quant_with_min_max_vars(data, input_min, input_max, num_bits, narrow_range, 'fq')
tf.compat.v1.global_variables_initializer()
tf_net = sess.graph_def
# reference graph to compare with IR
ref_net = None
if check_ir_version(10, None, ir_version) and not use_new_frontend:
levels = 2 ** num_bits - int(narrow_range)
# data (shape, value) -> const (shape, vale) -> data (shape, no value)
const_for_layer_tests = lambda name, value: {
**{name + '_dd': {'kind': 'data', 'value': value, 'shape': value.shape}},
**{name: {'kind': 'op', 'type': 'Const'}},
**shaped_data(name + '_d', int64_array(value.shape))}
connect_const_for_layer_tests = lambda first_tensor_name, second_tensor_name: [
*connect_front(first_tensor_name + '_dd', first_tensor_name),
*connect(first_tensor_name, second_tensor_name)]
nodes = {
**regular_op_with_shaped_data('parameter', [11], {'type': 'Parameter'}),
**const_for_layer_tests('il', np.array([nudged_il], dtype=np.float32)),
**const_for_layer_tests('ih', np.array([nudged_ih], dtype=np.float32)),
**const_for_layer_tests('ol', np.array([nudged_il], dtype=np.float32)),
**const_for_layer_tests('oh', np.array([nudged_ih], dtype=np.float32)),
**regular_op_with_shaped_data('fq', [11], {'type': 'FakeQuantize', 'levels': levels}),
**regular_op('result', {'type': 'Result'}),
}
edges = [
*connect('parameter', '0:fq'),
*connect_const_for_layer_tests('il', '1:fq'),
*connect_const_for_layer_tests('ih', '2:fq'),
*connect_const_for_layer_tests('ol', '3:fq'),
*connect_const_for_layer_tests('oh', '4:fq'),
*connect('fq', 'result'),
]
ref_net = build_graph(nodes, edges)
return tf_net, ref_net
def test_slice_infer_negative(self,
inp_value,
starts,
ends,
axes,
steps,
expected,
inp_shape=None):
if inp_value is None:
input_node = shaped_data('data_1', int64_array(inp_shape))
else:
input_node = valued_data('data_1', int64_array(inp_value))
def convert_args(val, name=''):
if val is not None:
return valued_const_with_data(name, int64_array(val))
else:
return shaped_const_with_data(name, [0]) #fake shape
starts = convert_args(starts, 'starts')
ends = convert_args(ends, 'ends')
axes = convert_args(axes, 'axes')
steps = convert_args(steps, 'steps')
nodes = {
**input_node,
**regular_op_with_empty_data('slice', {'op': 'Slice'}),
**starts,
**ends,
**axes,
**steps
}
graph = build_graph(
nodes,
[('data_1', 'slice'), *connect('starts', '1:slice'),
*connect('ends', '2:slice'), *connect('axes', '3:slice'),
*connect('steps', '4:slice'), *connect('slice', 'slice_d')])
graph.stage = 'middle'
slice_node = Node(graph, 'slice')
self.assertRaises(Error, Slice.infer, slice_node)
def test_slice_infer(self,
inp_value,
starts,
ends,
axes,
steps,
expected,
inp_shape=None):
if inp_value is None:
input_node = shaped_data('data_1', int64_array(inp_shape))
else:
input_node = valued_data('data_1', int64_array(inp_value))
nodes = {
**input_node,
**regular_op_with_empty_data('slice', {'op': 'Slice'}),
**valued_const_with_data('starts', int64_array(starts)),
**valued_const_with_data('ends', int64_array(ends)),
**valued_const_with_data('axes', int64_array(axes)),
**valued_const_with_data('steps', int64_array(steps)),
}
graph = build_graph(
nodes,
[('data_1', 'slice'), *connect('starts', '1:slice'),
*connect('ends', '2:slice'), *connect('axes', '3:slice'),
*connect('steps', '4:slice'), *connect('slice', 'slice_d')])
graph.stage = 'middle'
slice_node = Node(graph, 'slice')
Slice.infer(slice_node)
if inp_value is not None:
self.assertTrue(
np.array_equal(slice_node.out_node().value, expected))
else:
self.assertTrue(
np.array_equal(slice_node.out_node().shape, expected))
def create_tf_random_uniform_net(self, global_seed, op_seed, x_shape,
min_val, max_val, input_type, precision,
ir_version, use_new_frontend):
tf.compat.v1.reset_default_graph()
# Create the graph and model
with tf.compat.v1.Session() as sess:
tf_x_shape = x_shape.copy()
tf_x_shape = permute_nchw_to_nhwc(tf_x_shape, use_new_frontend)
x = tf.compat.v1.placeholder(input_type, tf_x_shape, 'Input')
if global_seed is not None:
tf.compat.v1.random.set_random_seed(global_seed)
random_uniform = tf.random.uniform(x_shape,
seed=op_seed,
dtype=input_type,
minval=min_val,
maxval=max_val) + x
tf.compat.v1.global_variables_initializer()
tf_net = sess.graph_def
ref_net = None
if check_ir_version(10, None, ir_version) and not use_new_frontend:
const_for_layer_tests = lambda name, value, shape, shape1: {
**{
name + '_dd': {
'kind': 'data',
'value': value,
'shape': shape1
}
},
**{
name: {
'kind': 'op',
'type': 'Const'
}
},
**shaped_data(name + '_d', shape)
}
connect_const_for_layer_tests = lambda first_tensor_name, second_tensor_name: [
*connect_front(first_tensor_name + '_dd', first_tensor_name),
*connect(first_tensor_name, second_tensor_name)
]
nodes_attributes = {
**regular_op_with_shaped_data('input', x_shape, {
'type': 'Parameter'
}),
**const_for_layer_tests('shape', x_shape,
int64_array([len(x_shape)]),
int64_array([len(x_shape)])),
**const_for_layer_tests('min_val', min_val, int64_array([]),
int64_array([1])),
**const_for_layer_tests('max_val', max_val, int64_array([]),
int64_array([1])),
**regular_op_with_shaped_data('random_uniform', x_shape, {
'type': 'RandomUniform'
}),
**regular_op_with_shaped_data('convert', x_shape, {
'type': 'Convert'
}),
**regular_op_with_shaped_data('add', x_shape, {'type': 'Add'}),
**regular_op_with_shaped_data('result', x_shape, {
'type': 'Result'
}),
}
if precision == 'FP16' and input_type == tf.float32:
ref_net = build_graph(nodes_attributes, [
*connect_const_for_layer_tests('shape',
'0:random_uniform'),
*connect_const_for_layer_tests('min_val',
'1:random_uniform'),
*connect_const_for_layer_tests('max_val',
'2:random_uniform'),
*connect('random_uniform', 'convert'),
*connect('convert', '0:add'), *connect('input', '1:add'),
*connect('add', 'result')
])
else:
ref_net = build_graph(nodes_attributes, [
*connect_const_for_layer_tests('shape',
'0:random_uniform'),
*connect_const_for_layer_tests('min_val',
'1:random_uniform'),
*connect_const_for_layer_tests('max_val',
'2:random_uniform'),
*connect('random_uniform', '0:add'),
*connect('input', '1:add'), *connect('add', 'result')
])
return tf_net, ref_net
from openvino.tools.mo.utils.ir_engine.compare_graphs import compare_graphs
from unit_tests.utils.graph import build_graph, result, connect, regular_op_with_shaped_data, regular_op, shaped_data, \
valued_const_with_data, shaped_const_with_data, valued_data
nodes = {
**regular_op_with_shaped_data('placeholder1', [1, 16, 10, 10], {
'type': 'Parameter'
}),
**valued_const_with_data('split_1_axis', int64_array(1), {
'type': 'Const'
}),
**regular_op('split_1', {
'type': 'Split',
'can_be_fused': True
}),
**shaped_data('split_1_data1', [1, 4, 10, 10]),
**shaped_data('split_1_data2', [1, 4, 10, 10]),
**shaped_data('split_1_data3', [1, 4, 10, 10]),
**shaped_data('split_1_data4', [1, 4, 10, 10]),
**shaped_const_with_data('split_2_in_const_weights',
int64_array([3, 3, 4, 16]), {'type': 'Const'}),
**regular_op('split_2', {'type': 'Split'}),
**valued_data('split_2_data1', np.zeros([3, 3, 4, 4])),
**valued_data('split_2_data2', np.zeros([3, 3, 4, 4])),
**valued_data('split_2_data3', np.zeros([3, 3, 4, 4])),
**valued_data('split_2_data4', np.zeros([3, 3, 4, 4])),
**regular_op_with_shaped_data(
'conv2d_1', [1, 4, 8, 8], {
'type':
'Convolution',
'channel_dims':
