def backend_attrs(self):
# the same attributes as in a regular convolution and additional attributes 'deformable_group', 'group'
# and 'bilinear_interpolation_pad'
attrs = Convolution(self.graph, {}).backend_attrs() + ['deformable_group', 'group']
if self.get_opset() == 'opset8':
attrs.append('bilinear_interpolation_pad')
return attrs
def add_convolution_to_swap_xy_coordinates(graph: Graph, input_node: Node,
coordinates_size: int):
"""
The function add convolution node after the node 'input_node' to swap xy coordinates of the boxes produced
by the node 'input_node'. It is expected that box coordinates are located in the fastest changing dimension of the
'input_node' output, i.e. the input tensor could be reshaped to [num_boxes, 4] or [num_boxes, 5]. If the size is 5,
then the 0-th element for each of num_boxes blocks is not changed and element 1 is swapped with element 2, element 3
is swapped with element 4. This is the case when boxes coordinates are produced by the layer "Proposal". The exact
amount of elements in each block is equal to the 'coordinates_size' parameter.
:param graph: graph to operate on.
:param input_node: node producing boxes coordinates.
:param coordinates_size: integer value equal to 4 or 5.
:return convolution node that swaps coordinates.
"""
# swap of input tensor with 4 or 5 numbers describing boxes are supported
assert (coordinates_size in [4, 5])
input_reshape_4d_node = create_op_node_with_second_input(
graph, Reshape, int64_array([-1, 1, 1, coordinates_size]),
dict(name=input_node.name + '/reshape_4d'), input_node)
mark_input_as_in_correct_layout(input_reshape_4d_node, 0)
# do not mark second input because the reshape works in initial model layout and needs to be transformed to NCHW
mark_output_as_in_correct_layout(input_reshape_4d_node, 0)
if coordinates_size == 5:
# zero indexed element is not box coordinate ("batch id" in case of Proposal)
conv_filter_data = mo_array(
mo_array([[[[1, 0, 0, 0, 0], [0, 0, 1, 0, 0], [0, 1, 0, 0, 0],
[0, 0, 0, 0, 1], [0, 0, 0, 1, 0]]]],
dtype=np.float32))
else:
conv_filter_data = mo_array(
mo_array(
[[[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]]],
dtype=np.float32))
conv_filter_data = np.transpose(conv_filter_data, [2, 3, 0, 1])
conv_filter_const_op = Const(graph, dict(value=conv_filter_data))
conv_filter_const_node = conv_filter_const_op.create_node(
[], dict(name=input_node.name + '/weights'))
conv_op = Convolution(
graph, {
'bias_addable': True,
'channel_dims': mo_array([3]),
'batch_dims': mo_array([0]),
'input_feature_channel': 0,
'output_feature_channel': 1,
'group': 1,
'layout': 'NHWC',
})
return conv_op.create_node([input_reshape_4d_node, conv_filter_const_node],
dict(name=input_node.name + "/conv"))
def replace_timeheightconv(self, graph: Graph, node: Node):
req_time_offsets = node.soft_get('time_offsets')
offsets = node.soft_get("offsets", [[]])
all_time_offsets = list(set(offsets[:, 0]))
all_time_offsets.sort()
in_name = node.soft_get('name', node.id)
rename_node(node, in_name + '/to_delete')
# create memoryoffsets for context gathering
# we need concat if time offsets more than 1
concat = Concat(graph,
attrs={
'name': in_name + '/Concat',
'in_ports_count': len(all_time_offsets)
}).create_node()
i = 0
for t in all_time_offsets:
# if time offset included in required_time_offsets we don't need default value
has_default = t not in req_time_offsets
memoff = MemoryOffset(graph,
attrs={
'name':
in_name + '/MemoryOffset_' + str(i),
't':
t,
'has_default':
has_default,
'splitted':
False,
'pair_name':
in_name + '/MemoryOffset_pair_' + str(i)
}).create_node()
concat.in_port(i).connect(memoff.out_port(0))
memoff.in_port(0).connect(node.in_port(0).get_source())
i = i + 1
stride = node.soft_get("height_subsample", 1)
kernel = int64_array([0, 0])
kernel[0] = len(set(offsets[:, 0]))
kernel[1] = len(set(offsets[:, 1]))
pad_h = int64_array([0, 0])
pad_h[0] = -min(offsets[:, 1]) if min(offsets[:, 1]) < 0 else 0
pad_h[1] = stride * node.height_out - (node.height_in -
max([max(offsets[:, 1]), 0]))
dilation_t = (max(offsets[:, 0]) - min(offsets[:, 0])) / (
kernel[0] - 1) if kernel[0] > 1 else 1
dilation_h = (max(offsets[:, 1]) - min(offsets[:, 1])) / (
kernel[1] - 1) if kernel[0] > 1 else 1
conv_attrs = {
'name':
in_name,
'output':
node['out_channels'],
'height_in':
node.height_in,
'bias_term':
None,
'pad':
int64_array([[0, 0], [0, 0], [0, 0], pad_h]),
'pad_spatial_shape':
int64_array([[0, 0], pad_h]),
'dilation':
int64_array([1, 1, dilation_t, dilation_h]),
'kernel':
int64_array(
[node.out_channels, node.in_channels, kernel[0], kernel[1]]),
'stride':
int64_array([1, 1, 1, stride]),
'kernel_spatial':
kernel,
'input_feature_channel':
1,
'output_feature_channel':
0,
'channel_dims':
int64_array([1]),
'spatial_dims':
int64_array([2, 3]),
'batch_dims':
int64_array([0]),
'kernel_spatial_idx':
int64_array([2, 3]),
'group':
1,
'reshape_kernel':
True,
'bias_addable':
True,
}
conv = Convolution(graph, attrs=conv_attrs).create_node()
conv.in_port(0).connect(concat.out_port(0))
conv.in_port(1).connect(node.in_port(1).get_source())
# change layout for weights from OHWI to OIHW
# in future should be replaced by common Permute mechanics
weights = conv.in_port(1).get_source().node.value
weights = weights.reshape(
int64_array([node.out_channels, -1, node.in_channels]))
weights = weights.transpose(int64_array([0, 2, 1]))
weights = weights.flatten()
conv.in_port(1).get_source().node.value = weights
conv.in_port(2).connect(node.in_port(2).get_source())
node.out_port(0).get_connection().set_source(conv.out_port(0))
graph.remove_node(node.id)