def get_interpolate_attributes(node: Node) -> dict:
opset_to_default_values = {
'opset1': {
'mode': None,
'align_corners': 0,
'antialias': 0,
'pads_begin': 0,
'pads_end': 0,
'version': 'opset1'
},
'opset4': {
'mode': None,
'shape_calculation_mode': None,
'antialias': 0,
'pads_begin': int64_array([0]),
'pads_end': int64_array([0]),
'coordinate_transformation_mode': 'half_pixel',
'nearest_mode': 'round_prefer_floor',
'cube_coeff': -0.75,
'version': 'opset4'
},
}
opset = node.get_opset()
result = {}
if opset in opset_to_default_values:
default_values = opset_to_default_values[opset]
for attr in default_values.keys():
value = node.soft_get(attr, default=default_values[attr])
result[attr] = value
return result
else:
raise Error('Unsupported opset {} for node with name {}.'.format(
opset, node.soft_get('name', node.id)))
def infer(node: Node):
node_name = node.soft_get('name', node.id)
assert node.with_right_bound is not None, \
"Attribute \"with_right_bound\" is not defined"
assert len(node.in_nodes()) == 2, \
"Incorrect number of inputs for {} node".format(node.id)
if node.get_opset() != "extension":
assert node.has_valid('output_type'), \
'`output_type` attribute is not set for Bucketize node `{}`'.format(node_name)
assert node.output_type in [np.int64, np.int32], \
'Bucketize `output_type` attribute must be int32 or int64, `{}` found'.format(np.dtype(node.output_type).name)
output_shape = node.in_port(0).data.get_shape()
node.out_port(0).data.set_shape(output_shape)
input_value = node.in_port(0).data.get_value()
buckets_value = node.in_port(1).data.get_value()
# compute if all input is constant
if input_value is not None and buckets_value is not None:
node.out_port(0).data.set_value(
mo_array(np.digitize(input_value,
buckets_value,
right=node.with_right_bound),
dtype=node.output_type))
def _compare_attributes(self, first: Node, second: Node) -> bool:
"""
This function checks whether attributes of nodes first and second are identical (except attribute 'axes').
:param first: the first of compared nodes
:param second: the second of compared nodes
:return: True, if attributes of nodes are identical and False otherwise
"""
# If opsets of nodes are different, then nodes have different attributes.
fst_opset = first.get_opset()
snd_opset = second.get_opset()
if fst_opset != snd_opset:
return False
if fst_opset not in ['opset1', 'opset4']:
fst_name = first.soft_get('name', first.id)
snd_name = second.soft_get('name', second.id)
raise Error('Unsupported opset {} for nodes with names {} and {}'.format(fst_opset, fst_name, snd_name))
if fst_opset == 'opset1':
return self._compare_attributes_of_interpolate1(first, second)
else:
return self._compare_attributes_of_interpolate4(first, second)
def get_axes(node: Node) -> np.ndarray:
opset = node.get_opset()
if opset == 'opset1':
interp_axes = node.soft_get('axes', None)
return interp_axes if interp_axes is None else int64_array(interp_axes)
src_shape = node.in_port(0).data.get_shape()
assert src_shape is not None
input_rank = len(src_shape)
if len(node.in_ports()) == 3:
axes = list(range(0, input_rank))
else:
axes = node.in_port(3).get_source().data.get_value()
return int64_array(axes)
def infer(node: Node):
num_of_inputs = len(node.in_ports())
opset = node.get_opset()
max_num_of_inputs = 6 if opset == 'opset5' else 5
input_msg_fmt = 'NonMaxSuppression node {} from {} must have from 2 to {} inputs'
node_name = node.soft_get('name', node.id)
inputs_msg = input_msg_fmt.format(node_name, opset, max_num_of_inputs)
assert 2 <= num_of_inputs <= max_num_of_inputs, inputs_msg
boxes_shape = node.in_port(0).data.get_shape()
assert boxes_shape is not None, 'The shape of tensor with boxes is not defined'
scores_shape = node.in_port(1).data.get_shape()
assert scores_shape is not None, 'The shape of tensor with scores is not defined'
assert len(boxes_shape
) == 3, 'Length of tensors with boxes must be equal to 3'
assert len(scores_shape
) == 3, 'Length of tensors with scores must be equal to 3'
# According to the specification of the operation NonMaxSuppression,
# the input 'max_output_boxes_per_class' (port 2) is optional, with default value 0.
if num_of_inputs >= 3:
max_output_boxes_per_class = node.in_port(2).data.get_value()
else:
max_output_boxes_per_class = 0
if not max_output_boxes_per_class:
log.info(
'Set default "max_output_boxes_per_class" for node {} to number of boxes'
.format(node.name))
max_output_boxes_per_class = boxes_shape[1]
# convert the np.array value to a scalar to avoid issue with ragged numpy array generation in the shape
# calculation formulas below
if isinstance(max_output_boxes_per_class, np.ndarray):
max_output_boxes_per_class = max_output_boxes_per_class.item()
num_classes = scores_shape[1]
num_input_boxes = boxes_shape[1]
assert scores_shape[2] is dynamic_dimension or scores_shape[2] == num_input_boxes or scores_shape[2] is None \
or num_input_boxes is None, 'Number of boxes mismatch for operation {}'.format(node_name)
if node.get_opset() in ['opset4', 'opset5']:
max_number_of_boxes = min(
num_input_boxes,
max_output_boxes_per_class) * boxes_shape[0] * num_classes
else:
max_number_of_boxes = min(
num_input_boxes,
boxes_shape[0] * max_output_boxes_per_class * num_classes)
node.out_port(0).data.set_shape(shape_array([max_number_of_boxes, 3]))
if opset == 'opset5':
node.out_port(0).data.set_shape(
shape_array([dynamic_dimension_value, 3]))
num_of_outputs = len([
port for port in node.out_ports().values()
if not port.disconnected()
])
if num_of_outputs >= 2 and node.has_port('out', 1):
node.out_port(1).data.set_shape(
shape_array([dynamic_dimension_value, 3]))
if num_of_outputs >= 3 and node.has_port('out', 2):
node.out_port(2).data.set_shape(shape_array([1]))