def extract(cls, 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 cls.enabled
def extract(cls, node):
proto_layer = node.pb
param = proto_layer.eltwise_param
input_len = len(node.in_edges())
eltwise_caffe_map = {
0: EltwiseNMul if input_len > 2 else Mul,
1: EltwiseNAdd if input_len > 2 else Add,
2: EltwiseNMax if input_len > 2 else Maximum,
}
operation = int(param.operation)
if operation not in eltwise_caffe_map:
raise Exception(
'Unsupported type of operation in Eltwise layer: ' + node.name)
lin_op_class = eltwise_caffe_map[operation]
mapping_rule = merge_attrs(param, {'coeff': np.array(param.coeff)})
mapping_rule.update(layout_attrs())
assert len(param.coeff) <= input_len
lin_op_class.update_node_stat(node, mapping_rule)
return cls.enabled
def extract(cls, node):
proto_layer = node.pb
param = proto_layer.prior_box_param
variance = param.variance
if len(variance) == 0:
variance = [0.1]
update_attrs = {
'width': list(param.width),
'height': list(param.height),
'flip': int(param.flip),
'clip': int(param.clip),
'variance': list(variance),
'img_size': param.img_size,
'img_h': param.img_h,
'img_w': param.img_w,
'step': param.step,
'step_h': param.step_h,
'step_w': param.step_w,
'offset': param.offset,
}
mapping_rule = merge_attrs(param, update_attrs)
mapping_rule.update(layout_attrs())
# update the attributes of the node
PriorBoxClusteredOp.update_node_stat(node, mapping_rule)
return cls.enabled
def extract(cls, node):
proto_layer = node.pb
param = proto_layer.region_yolo_param
flatten_param = proto_layer.flatten_param
axis = flatten_param.axis
end_axis = flatten_param.end_axis
coords = param.coords
classes = param.classes
num = param.num
update_attrs = {
'coords': coords,
'classes': classes,
'num': num,
'do_softmax': int(param.do_softmax),
'anchors': np.array(param.anchors),
'mask': np.array(param.mask)
}
flatten_attrs = {
'axis': axis,
'end_axis': end_axis
}
mapping_rule = merge_attrs(param, update_attrs)
mapping_rule.update(flatten_attrs)
mapping_rule.update(layout_attrs())
# update the attributes of the node
RegionYoloOp.update_node_stat(node, mapping_rule)
return cls.enabled
def extract(cls, node):
proto_layer = node.pb
param = proto_layer.tile_param
mapping_rule = {
'axis': int(param.axis),
'tiles': int(param.tiles),
}
mapping_rule = merge_attrs(param, mapping_rule)
AttributedTile.update_node_stat(node, mapping_rule)
return cls.enabled
def extract(cls, node):
proto_layer = node.pb
param = proto_layer.grn_param
update_attrs = {
'bias': param.bias,
}
mapping_rule = merge_attrs(param, update_attrs)
# update the attributes of the node
GRNOp.update_node_stat(node, mapping_rule)
return cls.enabled
def extract(cls, node):
proto_layer = node.pb
param = proto_layer.ctc_decoder_param
update_attrs = {
'ctc_merge_repeated': (int)(param.ctc_merge_repeated)
}
mapping_rule = merge_attrs(param, update_attrs)
mapping_rule.update(layout_attrs())
# update the attributes of the node
CTCGreedyDecoderOp.update_node_stat(node, mapping_rule)
return cls.enabled
def extract(cls, node):
proto_layer = node.pb
param = proto_layer.reorg_yolo_param
stride = param.stride
update_attrs = {
'stride': stride,
}
mapping_rule = merge_attrs(param, update_attrs)
mapping_rule.update(layout_attrs())
# update the attributes of the node
ReorgYoloOp.update_node_stat(node, mapping_rule)
return cls.enabled
def extract(cls, node):
proto_layer = node.pb
param = proto_layer.argmax_param
update_attrs = {
'out_max_val': int(param.out_max_val),
'top_k': param.top_k,
'axis': param.axis,
}
mapping_rule = merge_attrs(param, update_attrs)
ArgMaxOp.update_node_stat(node, mapping_rule)
# ArgMax must be converted to TopK but without the output with values
ArgMaxOp.update_node_stat(node, {'remove_values_output': True})
return cls.enabled
def extract(cls, node):
proto_layer = node.pb
param = proto_layer.psroi_pooling_param
update_attrs = {
'spatial_scale': param.spatial_scale,
'output_dim': param.output_dim,
'group_size': param.group_size,
}
mapping_rule = merge_attrs(param, update_attrs)
mapping_rule.update(layout_attrs())
# update the attributes of the node
PSROIPoolingOp.update_node_stat(node, mapping_rule)
return cls.enabled
def extract(cls, node):
proto_layer = node.pb
param = proto_layer.proposal_param
update_attrs = {
'feat_stride': param.feat_stride,
'base_size': param.base_size,
'min_size': param.min_size,
'ratio': np.array(param.ratio),
'scale': np.array(param.scale),
'pre_nms_topn': param.pre_nms_topn,
'post_nms_topn': param.post_nms_topn,
'nms_thresh': param.nms_thresh
}
mapping_rule = merge_attrs(param, update_attrs)
# update the attributes of the node
ProposalOp.update_node_stat(node, mapping_rule)
return cls.enabled
def extract(cls, node):
proto_layer = node.pb
param = proto_layer.prior_box_param
variance = param.variance
if len(variance) == 0:
variance = [0.1]
update_attrs = {
'aspect_ratio': np.array(param.aspect_ratio),
'min_size': np.array(param.min_size),
'max_size': np.array(param.max_size),
'flip': int(param.flip),
'clip': int(param.clip),
'variance': list(variance),
'img_size': param.img_size,
'img_h': param.img_h,
'img_w': param.img_w,
'step': param.step,
'step_h': param.step_h,
'step_w': param.step_w,
'offset': param.offset,
}
# these params can be omitted in caffe.proto and in param as consequence,
# so check if it is set or set to default
fields = [field[0].name for field in param.ListFields()]
if 'density' in fields:
update_attrs['density'] = np.array(param.density)
if 'fixed_size' in fields:
update_attrs['fixed_size'] = np.array(param.fixed_size)
if 'fixed_ratio' in fields:
update_attrs['fixed_ratio'] = np.array(param.fixed_ratio)
mapping_rule = merge_attrs(param, update_attrs)
mapping_rule.update(layout_attrs())
# update the attributes of the node
PriorBoxOp.update_node_stat(node, mapping_rule)
return cls.enabled
def extract(cls, node):
proto_layer = node.pb
pb_model = node.model_pb
param = proto_layer.prelu_param
update_attrs = {'channel_shared': int(param.channel_shared)}
variance_norm_caffe_map = {
0: 'caffe.FillerParameter.FAN_IN',
1: 'caffe.FillerParameter.FAN_OUT',
2: 'caffe.FillerParameter.AVERAGE'
}
if hasattr(param, 'filler'):
update_attrs.update({
'filler_type':
param.filler.type,
'filler_value':
int(param.filler.value),
'min':
int(param.filler.min),
'max':
int(param.filler.max),
'mean':
int(param.filler.mean),
'std':
int(param.filler.std),
'sparse':
param.filler.sparse,
'variance_norm':
variance_norm_caffe_map[param.filler.variance_norm]
})
mapping_rule = merge_attrs(param, update_attrs)
mapping_rule.update(weights_biases(False, pb_model))
mapping_rule.update(layout_attrs())
# update the attributes of the node
PReLU.update_node_stat(node, mapping_rule)
return cls.enabled
def extract(cls, 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 cls.enabled
def extract(cls, node):
pl = node.pb
assert pl, 'Protobuf layer can not be empty'
param = pl.detection_output_param
# TODO rewrite params as complex structures
if hasattr(param, 'nms_param'):
nms_threshold = param.nms_param.nms_threshold
eta = param.nms_param.eta
if param.nms_param.top_k == 0:
top_k = -1
else:
top_k = param.nms_param.top_k
code_type_values = [
"", "caffe.PriorBoxParameter.CORNER",
"caffe.PriorBoxParameter.CENTER_SIZE",
"caffe.PriorBoxParameter.CORNER_SIZE"
]
code_type = code_type_values[1]
if hasattr(param, 'code_type'):
if param.code_type < 1 or param.code_type > 3:
log.error("Incorrect value of code_type parameter")
return
code_type = code_type_values[param.code_type]
visualize_threshold = param.visualize_threshold if param.visualize_threshold else 0.6
resize_mode_values = [
"", "caffe.ResizeParameter.WARP",
"caffe.ResizeParameter.FIT_SMALL_SIZE",
"caffe.ResizeParameter.FIT_LARGE_SIZE_AND_PAD"
]
if param.save_output_param.resize_param.resize_mode < 1 or param.save_output_param.resize_param.resize_mode > 3:
log.error("Incorrect value of resize_mode parameter")
return
resize_mode = resize_mode_values[
param.save_output_param.resize_param.resize_mode]
pad_mode_values = [
"", "caffe.ResizeParameter.CONSTANT",
"caffe.ResizeParameter.MIRRORED",
"caffe.ResizeParameter.REPEAT_NEAREST"
]
if param.save_output_param.resize_param.pad_mode < 1 or param.save_output_param.resize_param.pad_mode > 3:
log.error("Incorrect value of pad_mode parameter")
else:
pad_mode = pad_mode_values[
param.save_output_param.resize_param.pad_mode]
interp_mode_values = [
"", "caffe.ResizeParameter.LINEAR", "caffe.ResizeParameter.AREA",
"caffe.ResizeParameter.NEAREST", "caffe.ResizeParameter.CUBIC",
"caffe.ResizeParameter.LANCZOS4"
]
interp_mode = ""
for x in param.save_output_param.resize_param.interp_mode:
if x < 1 or x > 5:
log.error("Incorrect value of interp_mode parameter")
return
interp_mode += interp_mode_values[x]
attrs = {
'share_location':
int(param.share_location),
'background_label_id':
param.background_label_id,
'code_type':
code_type,
'variance_encoded_in_target':
int(param.variance_encoded_in_target),
'keep_top_k':
param.keep_top_k,
'confidence_threshold':
param.confidence_threshold,
'visualize':
param.visualize,
'visualize_threshold':
visualize_threshold,
'save_file':
param.save_file,
# nms_param
'nms_threshold':
nms_threshold,
'top_k':
top_k,
'eta':
eta,
# save_output_param
'output_directory':
param.save_output_param.output_directory,
'output_name_prefix':
param.save_output_param.output_name_prefix,
'output_format':
param.save_output_param.output_format,
'label_map_file':
param.save_output_param.label_map_file,
'name_size_file':
param.save_output_param.name_size_file,
'num_test_image':
param.save_output_param.num_test_image,
# save_output_param.resize_param
'prob':
param.save_output_param.resize_param.prob,
'resize_mode':
resize_mode,
'height':
param.save_output_param.resize_param.height,
'width':
param.save_output_param.resize_param.width,
'height_scale':
param.save_output_param.resize_param.height_scale,
'width_scale':
param.save_output_param.resize_param.width_scale,
'pad_mode':
pad_mode,
'pad_value':
','.join(
str(x)
for x in param.save_output_param.resize_param.pad_value),
'interp_mode':
interp_mode,
}
# these params can be omitted in caffe.proto and in param as consequence,
# so check if it is set or set to default
fields = [field[0].name for field in param.ListFields()]
if 'input_width' in fields:
attrs['input_width'] = param.input_width
if 'input_height' in fields:
attrs['input_height'] = param.input_height
if 'normalized' in fields:
attrs['normalized'] = int(param.normalized)
if 'objectness_score' in fields:
attrs['objectness_score'] = param.objectness_score
mapping_rule = merge_attrs(param, attrs)
# update the attributes of the node
DetectionOutput.update_node_stat(node, mapping_rule)
return cls.enabled
