未验证 提交 b1bea3e8 编写于 作者: J Jason 提交者: GitHub

Merge pull request #59 from SunAhong1993/develop

Develop
from .register import get_registered_layers
#custom layer import begins
# from . import roipooling
# from . import priorbox
# from . import permute
# from . import detection_out
# from . import normalize
# from . import select
from . import roipooling
from . import priorbox
from . import permute
from . import detectionoutput
from . import normalize
from . import select
from . import shufflechannel
from . import convolutiondepthwise
from . import axpy
#custom layer import ends
custom_layers = get_registered_layers()
......@@ -38,11 +40,25 @@ def has_layer(layer_type):
def get_params(layer, layer_type):
import re
if layer_type.lower() == "deconvolution" or layer_type.lower(
) == "convolutiondepthwise":
param_name = '_'.join(('convolution', 'param'))
elif layer_type.lower() == "normalize":
param_name = '_'.join(('norm', 'param'))
elif len(layer_type) - len(re.sub("[A-Z]", "", layer_type)) >= 2:
s = ''
tmp_name = ''
for i, ch in enumerate(layer_type):
if i == 0:
s += ch.lower()
continue
elif ch.isupper() and layer_type[i - 1].islower():
tmp_name += (s + '_')
s = ''
s += ch
tmp_name += s
param_name = '_'.join((tmp_name, 'param'))
else:
param_name = '_'.join((layer_type.lower(), 'param'))
return getattr(layer, param_name, None)
......
from .register import register
from x2paddle.core.util import *
def axpy_shape(input_shape):
assert len(input_shapes) == 3, "not valid input shape for axpy layer"
assert len(input_shapes[0]) == len(input_shapes[1]), 'should have same dims'
output_shape = input_shapes[1]
assert (input_shapes[2] == output_shape),\
"shape not consistent for axpy[%s <--> %s]" \
% (str(output_shape), str(input_shapes[2]))
return [output_shape]
def axpy_layer(inputs, input_shape=None, name=None):
alpha = inputs[0]
x = inputs[1]
y = inputs[2]
out = fluid.layers.elementwise_mul(x, alpha, axis=0)
out = fluid.layers.elementwise_add(out, y, name=name)
print(out)
def axpy_weights(name, data=None):
weights_name = []
return weights_name
register(kind='Axpy', shape=axpy_shape, layer=axpy_layer, weights=axpy_weights)
......@@ -18,19 +18,19 @@ def convolutiondepthwise_shape(input_shape,
[k_h, k_w] = [1, 1]
if isinstance(kernel_size, numbers.Number):
[k_h, k_w] = [kernel_size] * 2
elif isinstance(kernel_size, list):
elif isinstance(kernel_size, list) and len(kernel_size) > 0:
k_h = kernel_h if kernel_h else kernel_size[0]
k_w = kernel_w if kernel_w else kernel_size[len(kernel_size) - 1]
[s_h, s_w] = [1, 1]
if isinstance(stride, numbers.Number):
[s_h, s_w] = [stride] * 2
elif isinstance(stride, list):
elif isinstance(stride, list) and len(stride) > 0:
s_h = stride_h if stride_h else stride[0]
s_w = stride_w if stride_w else stride[len(stride) - 1]
[p_h, p_w] = [0, 0]
if isinstance(pad, numbers.Number):
[p_h, p_w] = [pad] * 2
elif isinstance(pad, list):
elif isinstance(pad, list) and len(pad) > 0:
p_h = pad_h if pad_h else pad[0]
p_w = pad_w if pad_w else pad[len(pad) - 1]
dila_len = len(dilation)
......@@ -67,24 +67,24 @@ def convolutiondepthwise_layer(inputs,
kernel_w=None,
stride_h=None,
stride_w=None,
input_shape=[],
input_shape=None,
name=None):
[k_h, k_w] = [1, 1]
if isinstance(kernel_size, numbers.Number):
[k_h, k_w] = [kernel_size] * 2
elif isinstance(kernel_size, list):
elif isinstance(kernel_size, list) and len(kernel_size) > 0:
k_h = kernel_h if kernel_h else kernel_size[0]
k_w = kernel_w if kernel_w else kernel_size[len(kernel_size) - 1]
[s_h, s_w] = [1, 1]
if isinstance(stride, numbers.Number):
[s_h, s_w] = [stride] * 2
elif isinstance(stride, list):
elif isinstance(stride, list) and len(stride) > 0:
s_h = stride_h if stride_h else stride[0]
s_w = stride_w if stride_w else stride[len(stride) - 1]
[p_h, p_w] = [0, 0]
if isinstance(pad, numbers.Number):
[p_h, p_w] = [pad] * 2
elif isinstance(pad, list):
elif isinstance(pad, list) and len(pad) > 0:
p_h = pad_h if pad_h else pad[0]
p_w = pad_w if pad_w else pad[len(pad) - 1]
input = inputs[0]
......
from .register import register
from x2paddle.core.util import *
def detectionoutput_shape(input_shape):
return [[-1, 6]]
def detectionoutput_layer(inputs,
nms_param=None,
background_label_id=0,
share_location=True,
keep_top_k=100,
confidence_threshold=0.1,
input_shape=None,
name=None):
if nms_param is None:
nms_param = {"nms_threshold": 0.3, "top_k": 10, "eta": 1.0}
mbox_conf_flatten = inputs[1]
mbox_priorbox = inputs[2]
mbox_priorbox_list = fluid.layers.split(mbox_priorbox, 2, dim=1)
pb = mbox_priorbox_list[0]
pbv = mbox_priorbox_list[1]
pb = fluid.layers.reshape(x=pb, shape=[-1, 4])
pbv = fluid.layers.reshape(x=pbv, shape=[-1, 4])
mbox_loc = inputs[0]
mbox_loc = fluid.layers.reshape(x=mbox_loc,
shape=[-1, mbox_conf_flatten.shape[1], 4])
default = {"nms_threshold": 0.3, "top_k": 10, "eta": 1.0}
fields = ['eta', 'top_k', 'nms_threshold']
for f in default.keys():
if not nms_param.has_key(f):
nms_param[f] = default[f]
out = fluid.layers.detection_output(
scores=mbox_conf_flatten,
loc=mbox_loc,
prior_box=pb,
prior_box_var=pbv,
background_label=background_label,
nms_threshold=nms_param["nms_threshold"],
nms_top_k=nms_param["top_k"],
keep_top_k=keep_top_k,
score_threshold=confidence_threshold,
nms_eta=nms_param["eta"])
return out
def detectionoutput_weights(name, data=None):
weights_name = []
return weights_name
register(kind='DetectionOutput',
shape=detectionoutput_shape,
layer=detectionoutput_layer,
weights=detectionoutput_weights)
from .register import register
from x2paddle.core.util import *
def normalize_shape(input_shape):
return input_shape
def normalize_layer(inputs,
across_spatial=None,
channel_shared=None,
input_shape=None,
name=None):
assert across_spatial == False, "Only support across_spatial == False for Normalize"
input = inputs[0]
l2_norm = fluid.layers.l2_normalize(input, axis=1, name=name + '_l2')
scale_param = fluid.layers.create_parameter(
shape=[1] if channel_shared else [input_shape[0][1]],
dtype=input.dtype,
attr=name + '_scale')
out = fluid.layers.elementwise_mul(x=l2_norm,
y=scale_param,
axis=-1 if channel_shared else 1)
return out
def normalize_weights(name, data=None):
weights_name = [name + '_scale']
return weights_name
register(kind='Normalize',
shape=normalize_shape,
layer=normalize_layer,
weights=normalize_weights)
from .register import register
from x2paddle.core.util import *
def permute_shape(input_shape, order=None):
inshape = input_shape[0]
output_shape = []
for ii in order:
assert ii < len(inshape), "invalid order for permute[%s]" % (name)
output_shape.append(inshape[ii])
return [output_shape]
def permute_layer(inputs, order=None, input_shape=None, name=None):
input = inputs[0]
order = list(order)
out = fluid.layers.transpose(input, perm=order, name=name)
return out
def permute_weights(name, data=None):
weights_name = []
return weights_name
register(kind='Permute',
shape=permute_shape,
layer=permute_layer,
weights=permute_weights)
from .register import register
from x2paddle.core.util import *
def priorbox_shape(input_shape, max_size=None, aspect_ratio=None):
fc_shape = input_shapes[0]
N = 1
if not max_size == None:
N += 1
if not aspect_ratio == None:
N += 2 * len(aspect_ratio)
N_bbx = fc_shape[2] * fc_shape[3] * N
output_shape = [1, 2, 4 * N_bbx]
return [output_shape]
def priorbox_layer(inputs,
step=0.0,
offset=0.5,
min_size=None,
max_size=None,
aspect_ratio=[1.0],
flip=False,
clip=False,
variance=[0.1, 0.1, 0.2, 0.2],
input_shape=None,
name=None):
input = input_shape[0]
image = input_shape[1]
steps = tuple(step) if type(step) is list or type(step) is tuple else (step,
step)
box, variance_ = fluid.layers.prior_box(input,
image,
min_sizes=list(min_size),
max_sizes=list(max_size),
aspect_ratios=list(aspect_ratio),
variance=list(variance),
flip=flip,
clip=clip,
steps=step,
offset=offset,
name=name,
min_max_aspect_ratios_order=True)
box = fluid.layers.reshape(box, [1, 1, -1])
variance_ = fluid.layers.reshape(variance_, [1, 1, -1])
out = fluid.layers.concat([box, variance_], axis=1)
return out
def priorbox_weights(name, data=None):
weights_name = []
return weights_name
register(kind='PriorBox',
shape=priorbox_shape,
layer=priorbox_layer,
weights=priorbox_weights)
from .register import register
from x2paddle.core.util import *
def roipooling_shape(input_shape, pooled_w=None, pooled_h=None):
base_fea_shape = input_shapes[0]
rois_shape = input_shapes[1]
output_shape = base_fea_shape
output_shape[0] = rois_shape[0]
output_shape[2] = pooled_h
output_shape[3] = pooled_w
return [output_shape]
def roipooling_layer(inputs,
pooled_w=None,
pooled_h=None,
spatial_scale=None,
input_shape=None,
name=None):
input = inputs[0]
roi = inputs[1]
roi = fluid.layers.slice(roi, axes=[1], starts=[1], ends=[5])
out = fluid.layers.roi_pool(input,
roi,
pooled_height=pooled_h,
pooled_width=pooled_w,
spatial_scale=spatial_scale)
return out
def roipooling_weights(name, data=None):
weights_name = []
return weights_name
register(kind='ROIPooling',
shape=roipooling_shape,
layer=roipooling_layer,
weights=roipooling_weights)
from .register import register
from x2paddle.core.util import *
def select_shape(input_shape, axis=None, slice_point=None):
inshape = input_shape[0]
slice_point = slice_point
start = slice_point[0]
if len(slice_point) == 2:
end = slice_point[1]
else:
end = input_shape[axis]
assert end > start, "invalid slice_point with [start:%d, end:%d]" % (start,
end)
output_shape = input_shape
output_shape[axis] = end - start
return [output_shape]
def select_layer(inputs,
axis=None,
slice_point=None,
input_shape=None,
name=None):
input = inputs[0]
maxint32 = 2147483647
slice_point = [0] + slice_point
slice_point.append(maxint32)
i = 0
out = []
for i in range(len(slice_point)):
out.append(
fluid.layers.slice(input,
axes=[axis],
starts=[slice_point[i]],
ends=[slice_point[i + 1]],
name=name + '_' + str(i)))
if i == len(slice_point) - 2:
break
return out
def select_weights(name, data=None):
weights_name = []
return weights_name
register(kind='Select',
shape=select_shape,
layer=select_layer,
weights=select_weights)
from .register import register
from x2paddle.core.util import *
def shufflechannel_shape(input_shape):
return input_shape
def shufflechannel_layer(inputs, group=None, input_shape=None, name=None):
input = inputs[0]
out = fluid.layers.shuffle_channel(input, group=group, name=name)
return out
def shufflechannel_weights(name, data=None):
weights_name = []
return weights_name
register(kind='ShuffleChannel',
shape=shufflechannel_shape,
layer=shufflechannel_layer,
weights=shufflechannel_weights)
......@@ -27,6 +27,8 @@ class CaffeOpMapper(OpMapper):
self.weights = dict()
resolver = decoder.resolver
self.mylayers = {}
self.inputs = self.graph.input_nodes
self.outputs = self.graph.output_nodes
if resolver.has_pycaffe():
self.did_use_pb = False
else:
......@@ -124,36 +126,32 @@ class CaffeOpMapper(OpMapper):
data[idx] = np.squeeze(d, axis=sq_axis)
shape_new = data[idx].shape
print('shape-old' + str(shape_old))
print('shape-new' + str(shape_new))
if len(shape_old) != shape_new:
print('squeeze idx:%d, with kind:%s,name:%s' % \
(idx, node.layer_type, node.layer.name))
return data
def get_kernel_parameters(self, kind, params):
assert kind in [
'Convolution', 'Pooling', 'Deconvolution', 'ConvolutionDepthwise'
]
assert kind in ['Convolution', 'Pooling', 'Deconvolution']
[k_h, k_w] = [1, 1]
print(params.kernel_size)
if isinstance(params.kernel_size, numbers.Number):
[k_h, k_w] = [params.kernel_size] * 2
else:
elif isinstance(params.kernel_size,
list) and len(params.kernel_size) > 0:
k_h = params.kernel_h if params.kernel_h else params.kernel_size[0]
k_w = params.kernel_w if params.kernel_w else params.kernel_size[
len(params.kernel_size) - 1]
[s_h, s_w] = [1, 1]
if isinstance(params.stride, numbers.Number):
[s_h, s_w] = [params.stride] * 2
else:
elif isinstance(params.stride, list) and len(params.stride) > 0:
s_h = params.stride_h if params.stride_h else params.stride[0]
s_w = params.stride_w if params.stride_w else params.stride[
len(params.stride) - 1]
[p_h, p_w] = [0, 0]
if isinstance(params.pad, numbers.Number):
[p_h, p_w] = [params.pad] * 2
else:
elif isinstance(params.pad, list) and len(params.pad) > 0:
p_h = params.pad_h if params.pad_h else params.pad[0]
p_w = params.pad_w if params.pad_w else params.pad[len(params.pad) -
1]
......@@ -875,41 +873,6 @@ class CaffeOpMapper(OpMapper):
output='_, {}'.format(node.layer_name),
param_attr=attr)
def Axpy(self, node):
assert len(
node.inputs) == 3, 'The count of Axpy node\'s input is not 3.'
alpha = self.graph.get_bottom_node(node, idx=0, copy=True)
if self.is_Scale(alpha):
tmp = self.graph.get_bottom_node(alpha, idx=0, copy=True)
if self.is_BN(tmp):
alpha = tmp
x = self.graph.get_bottom_node(node, idx=1, copy=True)
if self.is_Scale(x):
tmp = self.graph.get_bottom_node(x, idx=0, copy=True)
if self.is_BN(tmp):
x = tmp
y = self.graph.get_bottom_node(node, idx=2, copy=True)
if self.is_Scale(y):
tmp = self.graph.get_bottom_node(y, idx=0, copy=True)
if self.is_BN(tmp):
y = tmp
attr = {'axis': 0, 'name': string(node.layer_name + '_mul')}
node.fluid_code.add_layer("elementwise_mul",
inputs={
'x': alpha,
'y': x
},
output=node,
param_attr=attr)
attr = {'name': string(node.layer_name + '_add')}
node.fluid_code.add_layer("elementwise_add",
inputs={
'x': node,
'y': y
},
output=node,
param_attr=attr)
def Crop(self, node):
assert len(
node.inputs) == 2, 'The count of Crop node\'s input is not 2.'
......@@ -943,83 +906,6 @@ class CaffeOpMapper(OpMapper):
output=node,
param_attr=attr)
def DetectionOutput(self, node):
assert len(
node.inputs
) == 3, 'The count of DetectionOutput node\'s input is not 3.'
mbox_loc = self.graph.get_bottom_node(node, idx=0, copy=True)
if self.is_Scale(mbox_loc):
tmp = self.graph.get_bottom_node(mbox_loc, idx=0, copy=True)
if self.is_BN(tmp):
mbox_loc = tmp
mbox_conf_flatten = self.graph.get_bottom_node(node, idx=1, copy=True)
if self.is_Scale(mbox_conf_flatten):
tmp = self.graph.get_bottom_node(mbox_conf_flatten,
idx=0,
copy=True)
if self.is_BN(tmp):
mbox_conf_flatten = tmp
mbox_priorbox = self.graph.get_bottom_node(node, idx=2, copy=True)
if self.is_Scale(mbox_priorbox):
tmp = self.graph.get_bottom_node(mbox_priorbox, idx=0, copy=True)
if self.is_BN(tmp):
mbox_priorbox = tmp
params = node.layer.detection_output_param
nms_threshold = 0.3
top_k = 10
eta = 1.0
if hasattr(params, 'nms_param'):
nms_threshold = getattr(params.nms_param, 'nms_threshold', 0.3)
top_k = getattr(params.nms_param, 'top_k', 10)
eta = getattr(params.nms_param, 'eta', 1.0)
background_label = getattr(params, 'background_label_id', 0)
share_location = getattr(params, 'share_location', True)
keep_top_k = getattr(params, 'keep_top_k', 100)
confidence_threshold = getattr(params, 'confidence_threshold', 0.1)
attr = {
'num_or_sections': 2,
'dim': 1,
'name': string(node.layer_name + '_split')
}
node.fluid_code.add_layer("split",
inputs=mbox_priorbox,
output='mbox_priorbox_list',
param_attr=attr)
node.fluid_code.add_note('pb = mbox_priorbox_list[0]')
node.fluid_code.add_note('pbv = mbox_priorbox_list[1]')
attr = {'shape': [-1, 4], 'name': string(node.layer_name + '_reshape1')}
node.fluid_code.add_layer("reshape",
inputs='pb',
output='pb',
param_attr=attr)
attr = {'shape': [-1, 4], 'name': string(node.layer_name + '_reshape2')}
node.fluid_code.add_layer("reshape",
inputs='pbv',
output='pbv',
param_attr=attr)
# TODO(syf): need chaeck
attr = {
'shape': [-1, node.input_shape[1][1], 4],
'name': string(node.layer_name + '_reshape3')
}
node.fluid_code.add_layer("reshape",
inputs=mbox_loc,
output='mbox_loc',
param_attr=attr)
attr = {
'background_label': background_label,
'nms_threshold': nms_threshold,
'nms_top_k': top_k,
'keep_top_k': keep_top_k,
'score_threshold': confidence_threshold,
'nms_eta': eta
}
inputs_str = get_input_name(mbox_conf_flatten) + ', mbox_loc, pb, pbv'
node.fluid_code.add_layer("detection_output",
inputs=inputs_str,
output=node,
param_attr=attr)
def Flatten(self, noed):
assert len(
node.inputs
......@@ -1036,68 +922,6 @@ class CaffeOpMapper(OpMapper):
output=node,
param_attr=attr)
def Normalize(self, node):
assert len(
node.inputs) == 1, 'The count of Normalize node\'s input is not 1.'
input = self.graph.get_bottom_node(node, idx=0, copy=True)
if self.is_Scale(input):
tmp = self.graph.get_bottom_node(input, idx=0, copy=True)
if self.is_BN(tmp):
input = tmp
params = node.layer.norm_param
across_spatial = params.across_spatial
channel_shared = params.channel_shared
assert across_spatial == False, "Only support across_spatial == False for Normalize"
attr = {'axis': 1, 'name': string(node.layer_name + '_l2')}
node.fluid_code.add_layer("l2_normalize",
inputs=input,
output=node.layer_name + '_l2',
param_attr=attr)
input_name = self.get_input_name(input)
data = node.data
assert data is not None, 'The parameter of {} (type is {}) is not set. You need to use python package of caffe to set the default value.'.format(
node.layer_name, node.layer_type)
data = self.adjust_parameters(node)
self.weights[node.layer_name + '_scale'] = data[0]
node.fluid_code.add_note(
'{}_scale_attr = ParamAttr(name=\'{}\')'.format(
node.layer_name, node.layer_name + '_scale'))
attr = {
'shape': [1] if channel_shared else [node.input_shape[0][1]],
'dtype': '{}.dtype'.format(input_name),
'attr': '{}_scale_attr'.format(node.layer_name),
'name': string(node.layer_name + '_param')
}
node.fluid_code.add_layer("create_parameter",
inputs=None,
output=node.layer_name + '_scale_param',
param_attr=attr)
attr = {
'axis': -1 if channel_shared else 1,
'name': string(node.layer_name + '_mul')
}
node.fluid_code.add_layer("elementwise_mul",
inputs=node.layer_name + '_l2, ' +
node.layer_name + '_scale_param',
output=node,
param_attr=attr)
def Permute(self, node):
assert len(
node.inputs) == 1, 'The count of Permute node\'s input is not 1.'
input = self.graph.get_bottom_node(node, idx=0, copy=True)
if self.is_Scale(input):
tmp = self.graph.get_bottom_node(input, idx=0, copy=True)
if self.is_BN(tmp):
input = tmp
params = node.layer.permute_param
order = list(params.order)
attr = {'order': order, 'name': string(node.layer_name)}
node.fluid_code.add_layer("transpose",
inputs=input,
output=node,
param_attr=attr)
def Power(self, node):
assert len(
node.inputs) == 1, 'The count of Permute node\'s input is not 1.'
......@@ -1126,69 +950,6 @@ class CaffeOpMapper(OpMapper):
output=node,
param_attr=attr)
def PriorBox(self, node):
assert len(
node.inputs) == 2, 'The count of PriorBox node\'s input is not 2.'
input1 = self.graph.get_bottom_node(node, idx=0, copy=True)
if self.is_Scale(input1):
tmp = self.graph.get_bottom_node(input1, idx=0, copy=True)
if self.is_BN(tmp):
input1 = tmp
input2 = self.graph.get_bottom_node(node, idx=1, copy=True)
if self.is_Scale(input2):
tmp = self.graph.get_bottom_node(input2, idx=0, copy=True)
if self.is_BN(tmp):
input2 = tmp
input_dict = {'input': input1, 'image': input2}
params = node.layer.prior_box_param
step = getattr(params, 'step', 0.0)
offset = getattr(params, 'offset', 0.5)
min_size = list(params.min_size)
max_size = list(params.max_size)
aspect_ratio = list(params.aspect_ratio)
flip = getattr(params, 'flip', False)
clip = getattr(params, 'clip', False)
variance = list(getattr(params, 'variance', [0.1, 0.1, 0.2, 0.2]))
steps = tuple(step) if type(step) is list or type(step) is tuple else (
step, step)
attr = {
'min_sizes': min_size,
'max_sizes': max_size,
'aspect_ratios': aspect_ratio,
'variance': variance,
'flip': flip,
'clip': clip,
'step': steps,
'offset': offset,
'min_max_aspect_ratios_order': True,
'name': string(node.layer_name)
}
node.fluid_code.add_layer("prior_box",
inputs=input_dict,
output='{}_box, {}_var'.format(
node.layer_name, node.layer_name),
param_attr=attr)
attr = {
'shape': [1, 1, -1],
}
node.fluid_code.add_layer("reshape",
inputs='{}_box'.format(node.layer_name),
output='{}_box'.format(node.layer_name),
param_attr=attr)
attr = {
'shape': [1, 1, -1],
}
node.fluid_code.add_layer("reshape",
inputs='{}_var'.format(node.layer_name),
output='{}_var'.format(node.layer_name),
param_attr=attr)
attr = {'axis': 1, 'name': string(node.layer_name + '_concat')}
node.fluid_code.add_layer("concat",
inputs='[{}_box, {}_var]'.format(
node.layer_name, node.layer_name),
output=node,
param_attr=attr)
def Reduction(self, node):
assert len(
node.inputs) == 1, 'The count of Reduction node\'s input is not 1.'
......@@ -1263,86 +1024,6 @@ class CaffeOpMapper(OpMapper):
output=node,
param_attr=attr)
def ROIPooling(self, node):
assert len(
node.inputs) == 2, 'The count of ROIPooling node\'s input is not 2.'
input1 = self.graph.get_bottom_node(node, idx=0, copy=True)
if self.is_Scale(input1):
tmp = self.graph.get_bottom_node(input1, idx=0, copy=True)
if self.is_BN(tmp):
input1 = tmp
input2 = self.graph.get_bottom_node(node, idx=1, copy=True)
if self.is_Scale(input2):
tmp = self.graph.get_bottom_node(input2, idx=0, copy=True)
if self.is_BN(tmp):
input2 = tmp
attr = {'axes': [1], 'starts': [1], 'ends': [5]}
node.fluid_code.add_layer("slice",
inputs=input2,
output=input2,
param_attr=attr)
input_dict = {'input': input1, 'rois': input2}
params = node.layer.roi_pooling_param
attr = {
'pooled_w': params.pooled_w,
'pooled_h': params.pooled_h,
'spatial_scale': params.spatial_scale,
'name': string(node.layer_name)
}
node.fluid_code.add_layer("roi_pool",
inputs=input_dict,
output=node,
param_attr=attr)
def Select(self, node):
assert len(
node.inputs) == 1, 'The count of Select node\'s input is not 1.'
input = self.graph.get_bottom_node(node, idx=0, copy=True)
if self.is_Scale(input):
tmp = self.graph.get_bottom_node(input, idx=0, copy=True)
if self.is_BN(tmp):
input = tmp
params = node.layer.select_param
slice_point = list(params.slice_point)
axis = params.axis
maxint32 = 2147483647
slice_point = [0] + slice_point
slice_point.append(maxint32)
i = 0
node.fluid_code.add_note('{} = []'.format(node.layer_name))
for i in range(len(slice_point)):
attr = {
'axes': [axis],
'starts': [slice_point[i]],
'ends': [slice_point[i + 1]],
'name': string(node.layer_name + '_' + str(i))
}
node.fluid_code.add_layer("slice",
inputs=input,
output=string(node.layer_name + '_' +
str(i)),
param_attr=attr)
node.fluid_code.add_note('{}.append({})'.format(
node.layer_name, node.layer_name + '_' + str(i)))
if i == len(slice_point) - 2:
break
def ShuffleChannel(self, node):
assert len(node.inputs
) == 1, 'The count of ShuffleChannel node\'s input is not 1.'
params = node.layer.shuffle_channel_param
group = params.group
input = self.graph.get_bottom_node(node, idx=0, copy=True)
if self.is_Scale(input):
tmp = self.graph.get_bottom_node(input, idx=0, copy=True)
if self.is_BN(tmp):
input = tmp
attr = {'group': group, 'name': string(node.layer_name)}
node.fluid_code.add_layer("shuffle_channel",
inputs=input,
output=node,
param_attr=attr)
def deal_custom_layer(self, node):
op = node.layer_type
custom_code, func = make_custom_layer(node)
......@@ -1351,12 +1032,11 @@ class CaffeOpMapper(OpMapper):
kwargs['name'] = string(node.layer_name)
kwargs['input_shape'] = node.input_shape
data = node.data
assert data is not None, 'The parameter of {} (type is {}) is not set. You need to use python package of caffe to set the default value.'.format(
node.layer_name, node.layer_type)
data = self.adjust_parameters(node)
weights_name = deal_weights(node)
for i in range(len(data)):
self.weights[weights_name[i]] = data[i]
if data is not None:
data = self.adjust_parameters(node)
weights_name = deal_weights(node)
for i in range(len(data)):
self.weights[weights_name[i]] = data[i]
inputs_node = []
for i in range(len(node.inputs)):
input = self.graph.get_bottom_node(node, idx=i, copy=True)
......
......@@ -338,26 +338,11 @@ def shape_argmax(layer, input_shape):
return [outshape]
def shape_axpy(layer, input_shape):
assert len(input_shapes) == 3, "not valid input shape for axpy layer"
assert len(input_shapes[0]) == len(input_shapes[1]), 'should have same dims'
output_shape = input_shapes[1]
assert (input_shapes[2] == output_shape),\
"shape not consistent for axpy[%s <--> %s]" \
% (str(output_shape), str(input_shapes[2]))
return [output_shape]
def shape_crop(layer, input_shape):
assert len(input_shape) == 2, "the number of crop's inputs must be 2"
return [input_shape[1]]
def shape_detectionoutput(layer, input_shape):
return [[-1, 6]]
def shape_flatten(layer, input_shape):
assert len(input_shape) == 1, "the number of flatten's inputs must be 1"
params = layer.flatten_param
......@@ -375,43 +360,10 @@ def shape_flatten(layer, input_shape):
return [output_shape]
def shape_normalize(layer, input_shape):
return input_shape
def shape_permute(layer, input_shape):
params = layer.permute_param
order = list(params.order)
inshape = input_shape[0]
output_shape = []
for ii in order:
assert ii < len(inshape), "invalid order for permute[%s]" % (name)
output_shape.append(inshape[ii])
return [output_shape]
def shape_power(layer, input_shape):
return input_shape
def shape_priorbox(layer, input_shape):
params = layer.prior_box_param
min_size = list(params.min_size)
max_size = list(params.max_size)
aspect_ratio = list(params.aspect_ratio)
assert len(input_shapes[0]) == 2, "invalid inputs for Priorbox[%s]" % (name)
fc_shape = input_shapes[0][0]
N = 1
if not max_size == None:
N += 1
if not aspect_ratio == None:
N += 2 * len(aspect_ratio)
N_bbx = fc_shape[2] * fc_shape[3] * N
output_shape = [[1, 2, 4 * N_bbx]]
return output_shape
def shape_reduction(layer, input_shape):
params = layer.reduction_param
axis = params.axis
......@@ -419,46 +371,3 @@ def shape_reduction(layer, input_shape):
axis += len(input_shape[0]) + 1
assert axis <= len(input_shape[0]), 'invalid axis[%d] error' % (axis)
return [input_shape[0:axis]]
def shape_roipooling(layer, input_shape):
params = layer.roi_pooling_param
pooled_w = params.pooled_w
pooled_h = params.pooled_h
spatial_scale = params.spatial_scale
assert len(
input_shapes[0]) == 2, "not valid input shape for roipooling layer"
base_fea_shape = input_shapes[0][0]
rois_shape = input_shapes[0][1]
output_shape = base_fea_shape
output_shape[0] = rois_shape[0]
output_shape[2] = pooled_h
output_shape[3] = pooled_w
return [output_shape]
def shape_select(layer, input_shape):
input_shape = list(input_shape[0])
params = layer.select_param
axis = params.axis
slice_point = list(params.slice_point)
start = slice_point[0]
if len(slice_point) == 2:
end = slice_point[1]
else:
end = input_shape[axis]
assert end > start, "invalid slice_point with [start:%d, end:%d]"\
% (start, end)
output_shape = input_shape
output_shape[axis] = end - start
return [output_shape]
def shape_shufflechannel(layer, input_shape):
return input_shape
# def shape_convolutiondepthwise(layer, input_shape):
# params = layer.convolution_param
# return get_strided_kernel_output_shape(params, input_shape[0], math.floor)
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册