def extract(node):
proto_layer = node.pb
param = proto_layer.resample_param
types = [
"",
'nearest',
'linear',
'cubic',
'area',
]
resample_type = types[param.type]
update_attrs = {
'antialias': int(param.antialias),
'height': param.height,
'width': param.width,
'type': resample_type,
'factor': param.factor,
'fw': 'caffe',
}
mapping_rule = merge_attrs(param, update_attrs)
mapping_rule['mode'] = mapping_rule['type']
mapping_rule['axes'] = int64_array([2, 3])
mapping_rule.pop('type')
Interpolate.update_node_stat(node, mapping_rule)
return __class__.enabled
def extract(cls, node):
mapping_rule = {
'align_corners': int(node.pb.attr['align_corners'].b),
'mode': 'linear',
'axes': int64_array([1, 2]),
}
Interpolate.update_node_stat(node, mapping_rule)
return cls.enabled
def extract(node):
mapping_rule = {
'mode': 'nearest',
'antialias': 0,
'axes': int64_array([1, 2]),
}
Interpolate.update_node_stat(node, mapping_rule)
return __class__.enabled
def extract(node):
mapping_rule = {
'pads_begin': 0,
'pads_end': 0,
'align_corners': int(node.pb.attr['align_corners'].b),
'mode': 'linear',
'axes': int64_array([1, 2]),
}
Interpolate.update_node_stat(node, mapping_rule)
return __class__.enabled
def extract(cls, node):
attrs = get_mxnet_layer_attrs(node.symbol_dict)
scale = attrs.int("scale", 1)
num_filter = attrs.int("num_filter", 0)
mode = attrs.str("sample_type", None)
if mode == 'nearest':
node_attrs = {
'factor': attrs.int("scale", 1),
'mode': mode,
'antialias': 0,
'axes': int64_array([2, 3]),
}
Interpolate.update_node_stat(node, node_attrs)
elif mode == 'bilinear':
"""
Bilinear UpSampling uses deconvolution algorithm under the hood.
For MXNet Bilinear UpSampling op just wrapper over Deconvolution op.
Inputs data:
input1 - input data
input2 - deconvolution weight
"""
kernel = 2 * scale - scale % 2
stride = scale
pad = math.ceil((scale - 1) / 2)
num_group = num_filter
node_attrs = {
'op': __class__.op,
'type': 'Deconvolution',
'bias_addable': True,
'bias_term': False,
'pad': int64_array([[0, 0], [0, 0], [pad, pad], [pad, pad]]),
'pad_spatial_shape': int64_array([[pad, pad], [pad, pad]]),
'dilation': None,
'output_spatial_shape': None,
'output_shape': None,
'stride': int64_array([1, 1, stride, stride]),
'group': num_group,
'output': num_filter,
'kernel_spatial': int64_array([kernel, kernel]),
'input_feature_channel': 0,
'output_feature_channel': 1,
'kernel_spatial_idx': None,
'reshape_kernel': True,
'spatial_dims': None,
'channel_dims': int64_array([1]),
'batch_dims': int64_array([0]),
'layout': 'NCHW',
'get_pad': DeconvFrontExtractor.get_pad,
}
Convolution.update_node_stat(node, node_attrs)
return cls.enabled
def extract(node):
proto_layer = node.pb
param = proto_layer.interp_param
update_attrs = {
'height': param.height,
'width': param.width,
'zoom_factor': param.zoom_factor,
'shrink_factor': param.shrink_factor,
}
mapping_rule = merge_attrs(param, update_attrs)
mapping_rule.update({'fw': 'caffe', 'mode': 'linear', 'axes': int64_array([2, 3]),
'pads_begin': param.pad_beg, 'pads_end': param.pad_end, 'align_corners': 1})
Interpolate.update_node_stat(node, mapping_rule)
return __class__.enabled