def non_max_suppression(
boxes: NodeInput,
scores: NodeInput,
max_output_boxes_per_class: Optional[NodeInput] = None,
iou_threshold: Optional[NodeInput] = None,
score_threshold: Optional[NodeInput] = None,
soft_nms_sigma: Optional[NodeInput] = None,
box_encoding: str = "corner",
sort_result_descending: bool = True,
output_type: str = "i64",
name: Optional[str] = None,
) -> Node:
"""Return a node which performs NonMaxSuppression.
:param boxes: Tensor with box coordinates.
:param scores: Tensor with box scores.
:param max_output_boxes_per_class: Tensor Specifying maximum number of boxes
to be selected per class.
:param iou_threshold: Tensor specifying intersection over union threshold
:param score_threshold: Tensor specifying minimum score to consider box for the processing.
:param soft_nms_sigma: Tensor specifying the sigma parameter for Soft-NMS.
:param box_encoding: Format of boxes data encoding.
:param sort_result_descending: Flag that specifies whenever it is necessary to sort selected
boxes across batches or not.
:param output_type: Output element type.
:return: The new node which performs NonMaxSuppression
"""
if max_output_boxes_per_class is None:
max_output_boxes_per_class = make_constant_node(0, np.int64)
if iou_threshold is None:
iou_threshold = make_constant_node(0, np.float32)
if score_threshold is None:
score_threshold = make_constant_node(0, np.float32)
if soft_nms_sigma is None:
inputs = as_nodes(
boxes, scores, max_output_boxes_per_class, iou_threshold, score_threshold
)
else:
inputs = as_nodes(
boxes, scores, max_output_boxes_per_class, iou_threshold, score_threshold, soft_nms_sigma
)
attributes = {
"box_encoding": box_encoding,
"sort_result_descending": sort_result_descending,
"output_type": output_type,
}
return _get_node_factory_opset5().create("NonMaxSuppression", inputs, attributes)
def as_elementwise_compatible_nodes(*input_values): # type: (*NodeInput) -> List[Node]
"""Return all input values as ngraph Nodes with the same shape and element type.
Scalar values will be converted to ngraph Constant Nodes.
"""
input_nodes = [node for node in input_values
if issubclass(type(node), Node)] # type: List[Node]
if not input_nodes:
raise NotImplementedError('Operations on scalars only are not supported.')
shapes = {tuple(node.shape) for node in input_nodes}
if len(shapes) > 1:
log.warning('More than one different shape in input nodes %s.', input_nodes)
types = [node.get_element_type() for node in input_nodes]
unique_types = {repr(type) for type in types}
if len(unique_types) > 1:
log.warning('More than one different data type in input nodes %s.', input_nodes)
sorted_shapes = sorted(shapes, key=len)
broadcast_shape = sorted_shapes.pop()
broadcast_dtype = get_dtype(types.pop())
output_nodes = []
for input_value in input_values:
if issubclass(type(input_value), Node):
input_value = ng.broadcast(input_value, broadcast_shape)
output_nodes.append(input_value)
else:
input_value = make_constant_node(input_value, dtype=broadcast_dtype)
output_nodes.append(ng.broadcast(input_value, broadcast_shape))
return output_nodes
def as_elementwise_compatible_nodes(*input_values): # type: (*NodeInput) -> List[Node]
"""Return all input values as ngraph Nodes with the same shape and element type.
Scalar values will be converted to ngraph Constant Nodes.
"""
input_nodes = [node for node in input_values
if issubclass(type(node), Node)] # type: List[Node]
if not input_nodes:
raise NotImplementedError('Operations on scalars only are not supported.')
shapes = {tuple(node.shape) for node in input_nodes}
if len(shapes) > 1:
log.warning('More than one different shape in input nodes %s.', input_nodes)
types = [node.get_element_type() for node in input_nodes]
unique_types = {repr(type) for type in types}
if len(unique_types) > 1:
log.warning('More than one different data type in input nodes %s.', input_nodes)
sorted_shapes = sorted(shapes, key=len)
broadcast_shape = sorted_shapes.pop()
broadcast_dtype = get_dtype(types.pop())
output_nodes = []
for input_value in input_values:
if issubclass(type(input_value), Node):
input_value = ng.broadcast_to(input_value, broadcast_shape)
output_nodes.append(input_value)
else:
input_value = make_constant_node(input_value, dtype=broadcast_dtype)
output_nodes.append(ng.broadcast_to(input_value, broadcast_shape))
return output_nodes
def constant(value, dtype=None, name=None): # type: (NumericData, NumericType, str) -> Constant
"""Create a Constant node from provided value.
:param value: One of: array of values or scalar to initialize node with.
:param dtype: The data type of provided data.
:param name: Optional name for output node.
:return: The Constant node initialized with provided data.
"""
return make_constant_node(value, dtype)
def constant(value, dtype=None, name=None): # type: (NumericData, NumericType, str) -> Constant
"""Create a Constant node from provided value.
:param value: One of: array of values or scalar to initialize node with.
:param dtype: The data type of provided data.
:param name: Optional name for output node.
:return: The Constant node initialized with provided data.
"""
return make_constant_node(value, dtype)
def swish(
data: NodeInput,
beta: Optional[NodeInput] = None,
name: Optional[str] = None,
) -> Node:
"""Return a node which performing Swish activation function Swish(x, beta=1.0) = x * sigmoid(x * beta)).
:param data: Tensor with input data floating point type.
:return: The new node which performs Swish
"""
if beta is None:
beta = make_constant_node(1.0, np.float32)
return _get_node_factory_opset4().create("Swish", as_nodes(data, beta), {})
def test_non_max_suppression():
boxes_shape = [1, 1000, 4]
scores_shape = [1, 1, 1000]
boxes_parameter = ng.parameter(boxes_shape, name="Boxes", dtype=np.float32)
scores_parameter = ng.parameter(scores_shape, name="Scores", dtype=np.float32)
node = ng.non_max_suppression(boxes_parameter, scores_parameter, make_constant_node(1000, np.int64))
assert node.get_type_name() == "NonMaxSuppression"
assert node.get_output_size() == 3
assert node.get_output_partial_shape(0) == PartialShape([Dimension(0, 1000), Dimension(3)])
assert node.get_output_partial_shape(1) == PartialShape([Dimension(0, 1000), Dimension(3)])
assert list(node.get_output_shape(2)) == [1]
def constant(value, dtype=None, name=None): # type: (NumericData, NumericType, str) -> Constant
"""Return an ngraph Constant object with the specified value."""
return make_constant_node(value, dtype)
