Skip to content

X
X2Paddle

未来在这儿 / X2Paddle
与 Fork 源项目一致

Fork自 PaddlePaddle / X2Paddle

通知 1
Star 1
Fork 0
X
X2Paddle

体验新版 GitCode，发现更多精彩内容 >>

提交 5cd17103 编写于 作者: C Channingss
浏览文件
操作

[ONNX]fix bug: ndarray assignment destination may be read-only

上级 d8c0b3f5
隐藏空白更改
内联 并排
Showing with 383 addition and 340 deletion
x2paddle/op_mapper/onnx_op_mapper.py
浏览文件 @ 5cd17103
...@@ -246,8 +246,10 @@ class ONNXOpMapper(OpMapper): ...@@ -246,8 +246,10 @@ class ONNXOpMapper(OpMapper):
assert len(val_inps) == 1, 'directly_map error with multi inputs' assert len(val_inps) == 1, 'directly_map error with multi inputs'
if fluid_op not in ['shape']: if fluid_op not in ['shape']:
attr['name'] = string(node.layer_name) attr['name'] = string(node.layer_name)
node.fluid_code.add_layer( node.fluid_code.add_layer(fluid_op,
fluid_op, inputs=val_inps[0], output=val_outs[0], param_attr=attr) inputs=val_inps[0],
output=val_outs[0],
param_attr=attr)
def deal_custom_layer(self, node): def deal_custom_layer(self, node):
op = node.layer_type op = node.layer_type
...@@ -256,12 +258,11 @@ class ONNXOpMapper(OpMapper): ...@@ -256,12 +258,11 @@ class ONNXOpMapper(OpMapper):
params = get_params(node.layer, node.layer_type) params = get_params(node.layer, node.layer_type)
arg_names, kwargs = set_args(func, params) arg_names, kwargs = set_args(func, params)
kwargs['name'] = string(node.layer_name) kwargs['name'] = string(node.layer_name)
node.fluid_code.add_layer( node.fluid_code.add_layer(func.__code__.co_name,
func.__code__.co_name, inputs=node.inputs,
inputs=node.inputs, output=node,
output=node, param_attr=kwargs,
param_attr=kwargs, is_custom_layer=True)
is_custom_layer=True)
if op not in self.used_custom_layers: if op not in self.used_custom_layers:
self.used_custom_layers[op] = custom_code self.used_custom_layers[op] = custom_code
if op + '_child_func' not in self.used_custom_layers: if op + '_child_func' not in self.used_custom_layers:
...@@ -298,18 +299,21 @@ class ONNXOpMapper(OpMapper): ...@@ -298,18 +299,21 @@ class ONNXOpMapper(OpMapper):
'shape': val_y_reshaped, 'shape': val_y_reshaped,
'name': string(var_y_reshaped) 'name': string(var_y_reshaped)
} }
node.fluid_code.add_layer( node.fluid_code.add_layer('reshape',
'reshape', inputs=val_y,
inputs=val_y, output=var_y_reshaped,
output=var_y_reshaped, param_attr=attr_reshaped)
param_attr=attr_reshaped)
inputs = {'x': val_x, 'y': var_y_reshaped} inputs = {'x': val_x, 'y': var_y_reshaped}
node.fluid_code.add_layer( node.fluid_code.add_layer(op_type,
op_type, inputs=inputs, output=node, param_attr=attr) inputs=inputs,
output=node,
param_attr=attr)
else: else:
inputs = {'x': val_x, 'y': val_y} inputs = {'x': val_x, 'y': val_y}
node.fluid_code.add_layer( node.fluid_code.add_layer(op_type,
op_type, inputs=inputs, output=node, param_attr=attr) inputs=inputs,
output=node,
param_attr=attr)
def place_holder(self, node): def place_holder(self, node):
self.input_shapes.append(node.out_shapes[0]) self.input_shapes.append(node.out_shapes[0])
...@@ -327,8 +331,10 @@ class ONNXOpMapper(OpMapper): ...@@ -327,8 +331,10 @@ class ONNXOpMapper(OpMapper):
"append_batch_size": 'False' "append_batch_size": 'False'
} }
node.fluid_code.add_layer( node.fluid_code.add_layer("data",
"data", inputs=None, output=node, param_attr=attr) inputs=None,
output=node,
param_attr=attr)
def create_parameter(self, node, parameter=None): def create_parameter(self, node, parameter=None):
if parameter is not None: if parameter is not None:
...@@ -345,8 +351,10 @@ class ONNXOpMapper(OpMapper): ...@@ -345,8 +351,10 @@ class ONNXOpMapper(OpMapper):
'attr': string(node.layer_name), 'attr': string(node.layer_name),
'default_initializer': 'Constant(0.0)' 'default_initializer': 'Constant(0.0)'
} }
node.fluid_code.add_layer( node.fluid_code.add_layer("create_parameter",
"create_parameter", inputs=None, output=node, param_attr=attr) inputs=None,
output=node,
param_attr=attr)
def _pad_if_asymmetric(self, node, pads, val_name): # pads: SSEE def _pad_if_asymmetric(self, node, pads, val_name): # pads: SSEE
assert len(pads) & 1 == 0 assert len(pads) & 1 == 0
...@@ -410,8 +418,10 @@ class ONNXOpMapper(OpMapper): ...@@ -410,8 +418,10 @@ class ONNXOpMapper(OpMapper):
else: else:
attr['out_shape'] = out_shape attr['out_shape'] = out_shape
node.fluid_code.add_layer( node.fluid_code.add_layer(fluid_op,
fluid_op, inputs=val_x, output=node, param_attr=attr) inputs=val_x,
output=node,
param_attr=attr)
def RoiAlign(self, node): def RoiAlign(self, node):
val_x = self.graph.get_input_node(node, idx=0, copy=True) val_x = self.graph.get_input_node(node, idx=0, copy=True)
...@@ -427,14 +437,13 @@ class ONNXOpMapper(OpMapper): ...@@ -427,14 +437,13 @@ class ONNXOpMapper(OpMapper):
'spatial_scale': spatial_scale, 'spatial_scale': spatial_scale,
'sampling_ratio': sampling_ratio, 'sampling_ratio': sampling_ratio,
} }
node.fluid_code.add_layer( node.fluid_code.add_layer('roi_align',
'roi_align', inputs={
inputs={ 'input': val_x,
'input': val_x, 'rois': val_rois
'rois': val_rois },
}, output=node,
output=node, param_attr=attr)
param_attr=attr)
def MaxRoiPool(self, node): def MaxRoiPool(self, node):
val_x = self.graph.get_input_node(node, idx=0, copy=True) val_x = self.graph.get_input_node(node, idx=0, copy=True)
...@@ -447,14 +456,13 @@ class ONNXOpMapper(OpMapper): ...@@ -447,14 +456,13 @@ class ONNXOpMapper(OpMapper):
'pooled_width': pooled_width, 'pooled_width': pooled_width,
'spatial_scale': spatial_scale, 'spatial_scale': spatial_scale,
} }
node.fluid_code.add_layer( node.fluid_code.add_layer('roi_pool',
'roi_pool', inputs={
inputs={ 'input': val_x,
'input': val_x, 'rois': val_rois
'rois': val_rois },
}, output=node,
output=node, param_attr=attr)
param_attr=attr)
def Pad(self, node, op_independent=True): def Pad(self, node, op_independent=True):
val_x = self.graph.get_input_node(node, idx=0, copy=True) val_x = self.graph.get_input_node(node, idx=0, copy=True)
...@@ -491,27 +499,32 @@ class ONNXOpMapper(OpMapper): ...@@ -491,27 +499,32 @@ class ONNXOpMapper(OpMapper):
attr['paddings'] = paddings attr['paddings'] = paddings
if op_independent: if op_independent:
attr['name'] = string(node.layer_name) attr['name'] = string(node.layer_name)
node.fluid_code.add_layer( node.fluid_code.add_layer(fluid_op,
fluid_op, inputs=val_x, output=node, param_attr=attr) inputs=val_x,
output=node,
param_attr=attr)
else: else:
attr['name'] = string(node.layer_name + '_paded') attr['name'] = string(node.layer_name + '_paded')
node.fluid_code.add_layer( node.fluid_code.add_layer(fluid_op,
fluid_op, inputs=val_x,
inputs=val_x, output=node.layer_name + '_paded',
output=node.layer_name + '_paded', param_attr=attr)
param_attr=attr)
return node.layer_name + '_paded' return node.layer_name + '_paded'
def Unsqueeze(self, node): def Unsqueeze(self, node):
val_x = self.graph.get_input_node(node, idx=0, copy=True) val_x = self.graph.get_input_node(node, idx=0, copy=True)
axes = node.get_attr('axes') axes = node.get_attr('axes')
if len(val_x.out_shapes[0]) == 0: if len(val_x.out_shapes[0]) == 0:
node.fluid_code.add_layer( node.fluid_code.add_layer('assign',
'assign', inputs=val_x, output=node, param_attr=None) inputs=val_x,
output=node,
param_attr=None)
else: else:
attr = {'axes': axes, 'name': string(node.layer_name)} attr = {'axes': axes, 'name': string(node.layer_name)}
node.fluid_code.add_layer( node.fluid_code.add_layer('unsqueeze',
'unsqueeze', inputs=val_x, output=node, param_attr=attr) inputs=val_x,
output=node,
param_attr=attr)
def Shrink(self, node): def Shrink(self, node):
val_x = self.graph.get_input_node(node, idx=0, copy=True) val_x = self.graph.get_input_node(node, idx=0, copy=True)
...@@ -519,8 +532,10 @@ class ONNXOpMapper(OpMapper): ...@@ -519,8 +532,10 @@ class ONNXOpMapper(OpMapper):
lambd = node.get_attr('lambd') lambd = node.get_attr('lambd')
assert bias == 0.0, 'not support bias!=0' assert bias == 0.0, 'not support bias!=0'
attr = {'threshold': lambd, 'name': node.layer_name} attr = {'threshold': lambd, 'name': node.layer_name}
node.fluid_code.add_layer( node.fluid_code.add_layer('hard_shrink',
'hard_shrink', inputs=val_x, output=node, param_attr=attr) inputs=val_x,
output=node,
param_attr=attr)
def Constant(self, node): def Constant(self, node):
val_output = self.graph.get_node(node.layer.output[0], copy=True) val_output = self.graph.get_node(node.layer.output[0], copy=True)
...@@ -550,8 +565,10 @@ class ONNXOpMapper(OpMapper): ...@@ -550,8 +565,10 @@ class ONNXOpMapper(OpMapper):
if dtype.name == 'int64': if dtype.name == 'int64':
dtype = 'int32' dtype = 'int32'
attr = {'shape': shape, 'dtype': string(dtype), 'value': value} attr = {'shape': shape, 'dtype': string(dtype), 'value': value}
node.fluid_code.add_layer( node.fluid_code.add_layer('fill_constant',
'fill_constant', inputs=None, output=node, param_attr=attr) inputs=None,
output=node,
param_attr=attr)
else: else:
value = np.reshape(value, shape) value = np.reshape(value, shape)
self.weights[node.layer_name] = value self.weights[node.layer_name] = value
...@@ -562,8 +579,10 @@ class ONNXOpMapper(OpMapper): ...@@ -562,8 +579,10 @@ class ONNXOpMapper(OpMapper):
'attr': string(node.layer_name), 'attr': string(node.layer_name),
'default_initializer': 'Constant(0.0)' 'default_initializer': 'Constant(0.0)'
} }
node.fluid_code.add_layer( node.fluid_code.add_layer("create_parameter",
"create_parameter", inputs=None, output=node, param_attr=attr) inputs=None,
output=node,
param_attr=attr)
def Resize(self, node): def Resize(self, node):
self._interpolate(node) self._interpolate(node)
...@@ -584,15 +603,16 @@ class ONNXOpMapper(OpMapper): ...@@ -584,15 +603,16 @@ class ONNXOpMapper(OpMapper):
name_ones = node.layer_name + '_ones' name_ones = node.layer_name + '_ones'
attr_ones = {'shape': out_shape, 'dtype': string(val_x_dtype)} attr_ones = {'shape': out_shape, 'dtype': string(val_x_dtype)}
node.fluid_code.add_layer( node.fluid_code.add_layer('ones',
'ones', inputs=None, output=name_ones, param_attr=attr_ones) inputs=None,
output=name_ones,
param_attr=attr_ones)
inputs = {'x': name_ones, 'y': val_x} inputs = {'x': name_ones, 'y': val_x}
attr = {'name': string(node.layer_name)} attr = {'name': string(node.layer_name)}
node.fluid_code.add_layer( node.fluid_code.add_layer('elementwise_mul',
'elementwise_mul', inputs=inputs,
inputs=inputs, output=node.layer_name,
output=node.layer_name, param_attr=attr)
param_attr=attr)
def Gather(self, node): def Gather(self, node):
val_x = self.graph.get_input_node(node, idx=0, copy=True) val_x = self.graph.get_input_node(node, idx=0, copy=True)
...@@ -602,75 +622,72 @@ class ONNXOpMapper(OpMapper): ...@@ -602,75 +622,72 @@ class ONNXOpMapper(OpMapper):
assert len( assert len(
indices_shape) <= 2, "Gather op don't support dim of indice >2 " indices_shape) <= 2, "Gather op don't support dim of indice >2 "
if axis == 0 and len(indices_shape) <= 1: if axis == 0 and len(indices_shape) <= 1:
node.fluid_code.add_layer( node.fluid_code.add_layer('gather',
'gather', inputs={
inputs={ 'input': val_x,
'input': val_x, 'index': indices
'index': indices },
}, output=node,
output=node, param_attr=None)
param_attr=None)
elif axis > 0 and len(indices_shape) <= 1: elif axis > 0 and len(indices_shape) <= 1:
perm = list(range(len(val_x.out_shapes[0]))) perm = list(range(len(val_x.out_shapes[0])))
perm = [axis] + perm[:axis] + perm[axis + 1:] perm = [axis] + perm[:axis] + perm[axis + 1:]
attr_trans = {'perm': perm} attr_trans = {'perm': perm}
name_trans = val_x.layer_name + '_trans' name_trans = val_x.layer_name + '_trans'
node.fluid_code.add_layer( node.fluid_code.add_layer('transpose',
'transpose', inputs=val_x,
inputs=val_x, output=name_trans,
output=name_trans, param_attr=attr_trans)
param_attr=attr_trans) node.fluid_code.add_layer('gather',
node.fluid_code.add_layer( inputs={
'gather', 'input': name_trans,
inputs={ 'index': indices
'input': name_trans, },
'index': indices output=node,
}, param_attr=None)
output=node, node.fluid_code.add_layer('transpose',
param_attr=None) inputs=node,
node.fluid_code.add_layer( output=node,
'transpose', inputs=node, output=node, param_attr=attr_trans) param_attr=attr_trans)
elif len(indices_shape) > 1: elif len(indices_shape) > 1:
from functools import reduce from functools import reduce
reshape_shape = reduce(lambda x, y: x * y, indices_shape) reshape_shape = reduce(lambda x, y: x * y, indices_shape)
node.fluid_code.add_layer( node.fluid_code.add_layer('reshape',
'reshape', inputs=indices,
inputs=indices, output=indices,
output=indices, param_attr={'shape': [
param_attr={'shape': [ reshape_shape,
reshape_shape, ]})
]})
perm = list(range(len(val_x.out_shapes[0]))) perm = list(range(len(val_x.out_shapes[0])))
perm = [axis] + perm[:axis] + perm[axis + 1:] perm = [axis] + perm[:axis] + perm[axis + 1:]
attr_trans = {'perm': perm} attr_trans = {'perm': perm}
name_trans = val_x.layer_name + '_trans' name_trans = val_x.layer_name + '_trans'
node.fluid_code.add_layer( node.fluid_code.add_layer('transpose',
'transpose', inputs=val_x,
inputs=val_x, output=name_trans,
output=name_trans, param_attr=attr_trans)
param_attr=attr_trans) node.fluid_code.add_layer('gather',
node.fluid_code.add_layer( inputs={
'gather', 'input': name_trans,
inputs={ 'index': indices
'input': name_trans, },
'index': indices output=node,
}, param_attr=None)
output=node, node.fluid_code.add_layer('transpose',
param_attr=None) inputs=node,
node.fluid_code.add_layer( output=node,
'transpose', inputs=node, output=node, param_attr=attr_trans) param_attr=attr_trans)
val_x_shape = val_x.out_shapes[0] val_x_shape = val_x.out_shapes[0]
reshaped_shape = [] reshaped_shape = []
for i in perm: for i in perm:
reshaped_shape.append(indices_shape[i]) reshaped_shape.append(indices_shape[i])
for i in val_x_shape[:axis] + val_x_shape[axis + 1:]: for i in val_x_shape[:axis] + val_x_shape[axis + 1:]:
reshaped_shape.append(i) reshaped_shape.append(i)
node.fluid_code.add_layer( node.fluid_code.add_layer('reshape',
'reshape', inputs=node,
inputs=node, output=node,
output=node, param_attr={'shape': reshaped_shape})
param_attr={'shape': reshaped_shape})
def Slice(self, node): def Slice(self, node):
val_x = self.graph.get_input_node(node, idx=0, copy=True) val_x = self.graph.get_input_node(node, idx=0, copy=True)
...@@ -708,8 +725,10 @@ class ONNXOpMapper(OpMapper): ...@@ -708,8 +725,10 @@ class ONNXOpMapper(OpMapper):
if value > shape[axes[idx]]: if value > shape[axes[idx]]:
ends[idx] = shape[axes[idx]] ends[idx] = shape[axes[idx]]
attr = {"axes": axes, "starts": starts, "ends": ends} attr = {"axes": axes, "starts": starts, "ends": ends}
node.fluid_code.add_layer( node.fluid_code.add_layer('slice',
'slice', inputs=val_x, output=node, param_attr=attr) inputs=val_x,
output=node,
param_attr=attr)
def ConstantOfShape(self, node): def ConstantOfShape(self, node):
val_shape = self.graph.get_input_node(node, idx=0, copy=True) val_shape = self.graph.get_input_node(node, idx=0, copy=True)
...@@ -732,8 +751,10 @@ class ONNXOpMapper(OpMapper): ...@@ -732,8 +751,10 @@ class ONNXOpMapper(OpMapper):
if dtype.name == 'int64': if dtype.name == 'int64':
dtype = 'int32' dtype = 'int32'
attr = {'shape': shape, 'dtype': string(dtype), 'value': value} attr = {'shape': shape, 'dtype': string(dtype), 'value': value}
node.fluid_code.add_layer( node.fluid_code.add_layer('fill_constant',
'fill_constant', inputs=None, output=node, param_attr=attr) inputs=None,
output=node,
param_attr=attr)
def Split(self, node): def Split(self, node):
val_x = self.graph.get_input_node(node, idx=0, copy=True) val_x = self.graph.get_input_node(node, idx=0, copy=True)
...@@ -748,8 +769,10 @@ class ONNXOpMapper(OpMapper): ...@@ -748,8 +769,10 @@ class ONNXOpMapper(OpMapper):
'name': string(node.layer_name) 'name': string(node.layer_name)
} }
node.fluid_code.add_layer( node.fluid_code.add_layer('split',
'split', inputs=val_x, output=val_y, param_attr=attr) inputs=val_x,
output=val_y,
param_attr=attr)
def Reshape(self, node): def Reshape(self, node):
val_x = self.graph.get_input_node(node, idx=0, copy=True) val_x = self.graph.get_input_node(node, idx=0, copy=True)
...@@ -766,11 +789,10 @@ class ONNXOpMapper(OpMapper): ...@@ -766,11 +789,10 @@ class ONNXOpMapper(OpMapper):
shape, _, _ = self.get_dynamic_shape(val_shape.layer_name) shape, _, _ = self.get_dynamic_shape(val_shape.layer_name)
if val_shape.dtype == 'int64': if val_shape.dtype == 'int64':
val_shape_cast = val_shape.layer_name + '_cast' val_shape_cast = val_shape.layer_name + '_cast'
node.fluid_code.add_layer( node.fluid_code.add_layer('cast',
'cast', inputs=val_shape,
inputs=val_shape, output=val_shape_cast,
output=val_shape_cast, param_attr={'dtype': string('int32')})
param_attr={'dtype': string('int32')})
attr['actual_shape'] = val_shape_cast attr['actual_shape'] = val_shape_cast
else: else:
...@@ -788,8 +810,10 @@ class ONNXOpMapper(OpMapper): ...@@ -788,8 +810,10 @@ class ONNXOpMapper(OpMapper):
val_x.layer_name, val_reshaped.layer_name) val_x.layer_name, val_reshaped.layer_name)
attr['shape'] = shape attr['shape'] = shape
node.fluid_code.add_layer( node.fluid_code.add_layer('reshape',
'reshape', inputs=val_x, output=node, param_attr=attr) inputs=val_x,
output=node,
param_attr=attr)
def Cast(self, node): def Cast(self, node):
val_input = self.graph.get_input_node(node, idx=0, copy=True) val_input = self.graph.get_input_node(node, idx=0, copy=True)
...@@ -803,8 +827,10 @@ class ONNXOpMapper(OpMapper): ...@@ -803,8 +827,10 @@ class ONNXOpMapper(OpMapper):
if output_dtype: if output_dtype:
assert dtype == output_dtype, 'dtype of to unmatches output' assert dtype == output_dtype, 'dtype of to unmatches output'
attr = {'dtype': string(dtype)} attr = {'dtype': string(dtype)}
node.fluid_code.add_layer( node.fluid_code.add_layer('cast',
'cast', inputs=val_input, output=node, param_attr=attr) inputs=val_input,
output=node,
param_attr=attr)
def AveragePool(self, node): def AveragePool(self, node):
val_x = self.graph.get_input_node(node, idx=0, copy=True) val_x = self.graph.get_input_node(node, idx=0, copy=True)
...@@ -839,8 +865,10 @@ class ONNXOpMapper(OpMapper): ...@@ -839,8 +865,10 @@ class ONNXOpMapper(OpMapper):
"name": string(node.layer_name) "name": string(node.layer_name)
} }
node.fluid_code.add_layer( node.fluid_code.add_layer(fluid_op,
fluid_op, inputs=val_x, output=node, param_attr=attr) inputs=val_x,
output=node,
param_attr=attr)
def Concat(self, node): def Concat(self, node):
inputs = [] inputs = []
...@@ -852,15 +880,19 @@ class ONNXOpMapper(OpMapper): ...@@ -852,15 +880,19 @@ class ONNXOpMapper(OpMapper):
inputs.append(ipt.layer_name) inputs.append(ipt.layer_name)
axis = node.get_attr('axis') axis = node.get_attr('axis')
attr = {'axis': axis} attr = {'axis': axis}
node.fluid_code.add_layer( node.fluid_code.add_layer('concat',
'concat', inputs=inputs, output=node, param_attr=attr) inputs=inputs,
output=node,
param_attr=attr)
def Flatten(self, node): def Flatten(self, node):
val_x = self.graph.get_input_node(node, idx=0, copy=True) val_x = self.graph.get_input_node(node, idx=0, copy=True)
axis = node.get_attr('axis', 1) axis = node.get_attr('axis', 1)
attr = {"axis": str(axis), "name": string(node.layer_name)} attr = {"axis": str(axis), "name": string(node.layer_name)}
node.fluid_code.add_layer( node.fluid_code.add_layer('flatten',
'flatten', inputs=val_x, output=node, param_attr=attr) inputs=val_x,
output=node,
param_attr=attr)
def Gemm(self, node): def Gemm(self, node):
val_a = self.graph.get_input_node(node, idx=0, copy=True) val_a = self.graph.get_input_node(node, idx=0, copy=True)
...@@ -879,37 +911,33 @@ class ONNXOpMapper(OpMapper): ...@@ -879,37 +911,33 @@ class ONNXOpMapper(OpMapper):
"alpha": alpha, "alpha": alpha,
"name": string(val_mm) "name": string(val_mm)
} }
node.fluid_code.add_layer( node.fluid_code.add_layer('matmul',
'matmul', inputs=matmul_inputs,
inputs=matmul_inputs, output=val_mm,
output=val_mm, param_attr=attr_matmul)
param_attr=attr_matmul)
if beta != 0: if beta != 0:
if beta == 1.: if beta == 1.:
add_inputs = {"x": val_mm, "y": val_c} add_inputs = {"x": val_mm, "y": val_c}
attr = {"name": string(node.layer_name)} attr = {"name": string(node.layer_name)}
node.fluid_code.add_layer( node.fluid_code.add_layer("elementwise_add",
"elementwise_add", inputs=add_inputs,
inputs=add_inputs, output=node,
output=node, param_attr=attr)
param_attr=attr)
else: else:
var_beta = node.layer_name + '_beta' var_beta = node.layer_name + '_beta'
matmul_beta_inputs = {"x": val_c, "y": var_beta} matmul_beta_inputs = {"x": val_c, "y": var_beta}
node.fluid_code.add_layer( node.fluid_code.add_layer("Constant",
"Constant", inputs=matmul_beta_inputs,
inputs=matmul_beta_inputs, output=var_beta,
output=var_beta, param_attr={'value': beta})
param_attr={'value': beta})
add_inputs = {"x": val_mm, "y": var_beta} add_inputs = {"x": val_mm, "y": var_beta}
attr = {"name": string(node.layer_name)} attr = {"name": string(node.layer_name)}
node.fluid_code.add_layer( node.fluid_code.add_layer("elementwise_add",
"elementwise_add", inputs=add_inputs,
inputs=add_inputs, output=node,
output=node, param_attr=attr)
param_attr=attr)
def Sum(self, node): def Sum(self, node):
val_inps = node.layer.input val_inps = node.layer.input
...@@ -925,16 +953,19 @@ class ONNXOpMapper(OpMapper): ...@@ -925,16 +953,19 @@ class ONNXOpMapper(OpMapper):
"x": node.layer_name, "x": node.layer_name,
"y": y, "y": y,
} }
node.fluid_code.add_layer( node.fluid_code.add_layer("elementwise_add",
"elementwise_add", inputs=inputs, output=node) inputs=inputs,
output=node)
def MatMul(self, node): def MatMul(self, node):
val_x = self.graph.get_input_node(node, idx=0, copy=True) val_x = self.graph.get_input_node(node, idx=0, copy=True)
val_y = self.graph.get_input_node(node, idx=1, copy=True) val_y = self.graph.get_input_node(node, idx=1, copy=True)
inputs = {"x": val_x, "y": val_y} inputs = {"x": val_x, "y": val_y}
attr = {"name": string(node.layer_name)} attr = {"name": string(node.layer_name)}
node.fluid_code.add_layer( node.fluid_code.add_layer("matmul",
"matmul", inputs=inputs, output=node, param_attr=attr) inputs=inputs,
output=node,
param_attr=attr)
def BatchNormalization(self, node): def BatchNormalization(self, node):
val_x = self.graph.get_input_node(node, idx=0, copy=True) val_x = self.graph.get_input_node(node, idx=0, copy=True)
...@@ -965,21 +996,27 @@ class ONNXOpMapper(OpMapper): ...@@ -965,21 +996,27 @@ class ONNXOpMapper(OpMapper):
"use_global_stats": spatial, "use_global_stats": spatial,
"name": string(node.layer_name) "name": string(node.layer_name)
} }
node.fluid_code.add_layer( node.fluid_code.add_layer("batch_norm",
"batch_norm", inputs=val_x, output=node, param_attr=attr) inputs=val_x,
output=node,
param_attr=attr)
def Transpose(self, node): def Transpose(self, node):
val_x = self.graph.get_input_node(node, idx=0, copy=True) val_x = self.graph.get_input_node(node, idx=0, copy=True)
perm = node.get_attr('perm') perm = node.get_attr('perm')
attr = {'perm': perm, "name": string(node.layer_name)} attr = {'perm': perm, "name": string(node.layer_name)}
node.fluid_code.add_layer( node.fluid_code.add_layer("transpose",
"transpose", inputs=val_x, output=node, param_attr=attr) inputs=val_x,
output=node,
param_attr=attr)
def Relu(self, node): def Relu(self, node):
val_x = self.graph.get_input_node(node, idx=0, copy=True) val_x = self.graph.get_input_node(node, idx=0, copy=True)
attr = {"name": string(node.layer_name)} attr = {"name": string(node.layer_name)}
node.fluid_code.add_layer( node.fluid_code.add_layer("relu",
"relu", inputs=val_x, output=node, param_attr=attr) inputs=val_x,
output=node,
param_attr=attr)
def PRelu(self, node): def PRelu(self, node):
val_x = self.graph.get_input_node(node, idx=0, copy=True) val_x = self.graph.get_input_node(node, idx=0, copy=True)
...@@ -995,27 +1032,30 @@ class ONNXOpMapper(OpMapper): ...@@ -995,27 +1032,30 @@ class ONNXOpMapper(OpMapper):
"param_attr": string(val_slope.layer_name), "param_attr": string(val_slope.layer_name),
'mode': string(mode) 'mode': string(mode)
} }
node.fluid_code.add_layer( node.fluid_code.add_layer("prelu",
"prelu", inputs=val_x, output=node, param_attr=attr) inputs=val_x,
output=node,
param_attr=attr)
def Squeeze(self, node): def Squeeze(self, node):
val_x = self.graph.get_input_node(node, idx=0, copy=True) val_x = self.graph.get_input_node(node, idx=0, copy=True)
axes = node.get_attr('axes') axes = node.get_attr('axes')
attr = {'axes': axes, "name": string(node.layer_name)} attr = {'axes': axes, "name": string(node.layer_name)}
node.fluid_code.add_layer( node.fluid_code.add_layer("squeeze",
"squeeze", inputs=val_x, output=node, param_attr=attr) inputs=val_x,
output=node,
param_attr=attr)
def Equal(self, node): def Equal(self, node):
val_x = self.graph.get_input_node(node, idx=0, copy=True) val_x = self.graph.get_input_node(node, idx=0, copy=True)
val_y = self.graph.get_input_node(node, idx=1, copy=True) val_y = self.graph.get_input_node(node, idx=1, copy=True)
node.fluid_code.add_layer( node.fluid_code.add_layer("equal",
"equal", inputs={
inputs={ 'x': val_x,
'x': val_x, 'y': val_y
'y': val_y },
}, output=node,
output=node, param_attr=None)
param_attr=None)
def Where(self, node): def Where(self, node):
condition = self.graph.get_input_node(node, idx=0, copy=True) condition = self.graph.get_input_node(node, idx=0, copy=True)
...@@ -1023,57 +1063,52 @@ class ONNXOpMapper(OpMapper): ...@@ -1023,57 +1063,52 @@ class ONNXOpMapper(OpMapper):
val_y = self.graph.get_input_node(node, idx=2, copy=True) val_y = self.graph.get_input_node(node, idx=2, copy=True)
not_condition = condition.layer_name + '_not' not_condition = condition.layer_name + '_not'
node.fluid_code.add_layer( node.fluid_code.add_layer("logical_not",
"logical_not", inputs=condition,
inputs=condition, output=not_condition,
output=not_condition, param_attr=None)
param_attr=None)
cast_not_condition = not_condition + '_cast' cast_not_condition = not_condition + '_cast'
node.fluid_code.add_layer( node.fluid_code.add_layer("cast",
"cast", inputs=not_condition,
inputs=not_condition, output=cast_not_condition,
output=cast_not_condition, param_attr={'dtype': string(val_x.dtype)})
param_attr={'dtype': string(val_x.dtype)})
cast_condition = condition.layer_name + '_cast' cast_condition = condition.layer_name + '_cast'
node.fluid_code.add_layer( node.fluid_code.add_layer("cast",
"cast", inputs=condition,
inputs=condition, output=cast_condition,
output=cast_condition, param_attr={'dtype': string(val_x.dtype)})
param_attr={'dtype': string(val_x.dtype)})
mul_val_x = val_x.layer_name + '_mul' mul_val_x = val_x.layer_name + '_mul'
node.fluid_code.add_layer( node.fluid_code.add_layer("elementwise_mul",
"elementwise_mul", inputs={
inputs={ 'x': val_x,
'x': val_x, 'y': cast_condition
'y': cast_condition },
}, output=mul_val_x,
output=mul_val_x, param_attr=None)
param_attr=None)
mul_val_y = val_y.layer_name + '_mul' mul_val_y = val_y.layer_name + '_mul'
node.fluid_code.add_layer( node.fluid_code.add_layer("elementwise_mul",
"elementwise_mul", inputs={
inputs={ 'x': val_y,
'x': val_y, 'y': cast_not_condition
'y': cast_not_condition },
}, output=mul_val_y,
output=mul_val_y, param_attr=None)
param_attr=None)
node.fluid_code.add_layer("elementwise_add",
node.fluid_code.add_layer( inputs={
"elementwise_add", 'x': mul_val_x,
inputs={ 'y': mul_val_y
'x': mul_val_x, },
'y': mul_val_y output=node,
}, param_attr=None)
output=node,
param_attr=None)
def NonZero(self, node): def NonZero(self, node):
val_x = self.graph.get_input_node(node, idx=0, copy=True) val_x = self.graph.get_input_node(node, idx=0, copy=True)
where_name = node.layer_name + '_where' where_name = node.layer_name + '_where'
node.fluid_code.add_layer( node.fluid_code.add_layer("where",
"where", inputs=val_x.layer_name + '!=0', output=where_name) inputs=val_x.layer_name + '!=0',
output=where_name)
dims = len(val_x.out_shapes[0]) dims = len(val_x.out_shapes[0])
elements_count_val_x = reduce(lambda x, y: x * y, val_x.out_shapes[0]) elements_count_val_x = reduce(lambda x, y: x * y, val_x.out_shapes[0])
flatten_names = [] flatten_names = []
...@@ -1086,15 +1121,18 @@ class ONNXOpMapper(OpMapper): ...@@ -1086,15 +1121,18 @@ class ONNXOpMapper(OpMapper):
'starts': [0, dim], 'starts': [0, dim],
'ends': [elements_count_val_x, dim + 1] 'ends': [elements_count_val_x, dim + 1]
} }
node.fluid_code.add_layer( node.fluid_code.add_layer("slice",
"slice", inputs=where_name, output=slice_name, param_attr=attr) inputs=where_name,
node.fluid_code.add_layer( output=slice_name,
"flatten", param_attr=attr)
inputs=slice_name, node.fluid_code.add_layer("flatten",
output=flatten_name, inputs=slice_name,
param_attr={'axis': 0}) output=flatten_name,
node.fluid_code.add_layer( param_attr={'axis': 0})
"concat", inputs=flatten_names, output=node, param_attr={'axis': 0}) node.fluid_code.add_layer("concat",
inputs=flatten_names,
output=node,
param_attr={'axis': 0})
def Identity(self, node): def Identity(self, node):
val_x = self.graph.get_input_node(node, idx=0, copy=True) val_x = self.graph.get_input_node(node, idx=0, copy=True)
...@@ -1113,8 +1151,10 @@ class ONNXOpMapper(OpMapper): ...@@ -1113,8 +1151,10 @@ class ONNXOpMapper(OpMapper):
'expand_times': repeats, 'expand_times': repeats,
"name": string(node.layer_name), "name": string(node.layer_name),
} }
node.fluid_code.add_layer( node.fluid_code.add_layer("expand",
"expand", inputs=val_x, output=node, param_attr=attr) inputs=val_x,
output=node,
param_attr=attr)
def MaxPool(self, node): def MaxPool(self, node):
val_x = self.graph.get_input_node(node, idx=0, copy=True) val_x = self.graph.get_input_node(node, idx=0, copy=True)
...@@ -1151,8 +1191,10 @@ class ONNXOpMapper(OpMapper): ...@@ -1151,8 +1191,10 @@ class ONNXOpMapper(OpMapper):
"name": string(node.layer_name), "name": string(node.layer_name),
"exclusive": False "exclusive": False
} }
node.fluid_code.add_layer( node.fluid_code.add_layer(fluid_op,
fluid_op, inputs=val_x, output=node, param_attr=attr) inputs=val_x,
output=node,
param_attr=attr)
def _global_pool(self, node): def _global_pool(self, node):
val_x = self.graph.get_input_node(node, idx=0, copy=True) val_x = self.graph.get_input_node(node, idx=0, copy=True)
...@@ -1178,8 +1220,10 @@ class ONNXOpMapper(OpMapper): ...@@ -1178,8 +1220,10 @@ class ONNXOpMapper(OpMapper):
"global_pooling": True, "global_pooling": True,
"name": string(node.layer_name) "name": string(node.layer_name)
} }
node.fluid_code.add_layer( node.fluid_code.add_layer(fluid_op,
fluid_op, inputs=val_x, output=node, param_attr=attr) inputs=val_x,
output=node,
param_attr=attr)
def GlobalMaxPool(self, node): def GlobalMaxPool(self, node):
self._global_pool(node) self._global_pool(node)
...@@ -1235,8 +1279,10 @@ class ONNXOpMapper(OpMapper): ...@@ -1235,8 +1279,10 @@ class ONNXOpMapper(OpMapper):
attr["bias_attr"] = string(val_b.layer_name) attr["bias_attr"] = string(val_b.layer_name)
else: else:
attr["bias_attr"] = False attr["bias_attr"] = False
node.fluid_code.add_layer( node.fluid_code.add_layer(fluid_op,
fluid_op, inputs=val_x, output=node, param_attr=attr) inputs=val_x,
output=node,
param_attr=attr)
def ConvTranspose(self, node): def ConvTranspose(self, node):
val_x = self.graph.get_input_node(node, idx=0, copy=True) val_x = self.graph.get_input_node(node, idx=0, copy=True)
...@@ -1286,8 +1332,10 @@ class ONNXOpMapper(OpMapper): ...@@ -1286,8 +1332,10 @@ class ONNXOpMapper(OpMapper):
'bias_attr': None if val_b is None else string(val_b.layer_name), 'bias_attr': None if val_b is None else string(val_b.layer_name),
'name': string(node.layer_name), 'name': string(node.layer_name),
} }
node.fluid_code.add_layer( node.fluid_code.add_layer(fluid_op,
fluid_op, inputs=val_x, output=node, param_attr=attr) inputs=val_x,
output=node,
param_attr=attr)
def GRU(self, node): def GRU(self, node):
val_x = self.graph.get_input_node(node, idx=0, copy=True) val_x = self.graph.get_input_node(node, idx=0, copy=True)
...@@ -1304,13 +1352,15 @@ class ONNXOpMapper(OpMapper): ...@@ -1304,13 +1352,15 @@ class ONNXOpMapper(OpMapper):
else: else:
miss_arg_num += 1 miss_arg_num += 1
if num_ipt > 4 and node.layer.input[4] != '': if num_ipt > 4 and node.layer.input[4] != '':
val_len = self.graph.get_input_node( val_len = self.graph.get_input_node(node,
node, idx=4 - miss_arg_num, copy=True) idx=4 - miss_arg_num,
copy=True)
else: else:
miss_arg_num += 1 miss_arg_num += 1
if num_ipt > 5 and node.layer.input[5] != '': if num_ipt > 5 and node.layer.input[5] != '':
val_xh = self.graph.get_input_node( val_xh = self.graph.get_input_node(node,
node, idx=5 - miss_arg_num, copy=True) idx=5 - miss_arg_num,
copy=True)
data, dtype, shape = self.get_dynamic_shape(val_x.layer_name) data, dtype, shape = self.get_dynamic_shape(val_x.layer_name)
...@@ -1351,101 +1401,97 @@ class ONNXOpMapper(OpMapper): ...@@ -1351,101 +1401,97 @@ class ONNXOpMapper(OpMapper):
is_reverse = direction == 'reverse' is_reverse = direction == 'reverse'
var_x0 = node.layer_name + '_x0' var_x0 = node.layer_name + '_x0'
node.fluid_code.add_layer( node.fluid_code.add_layer('squeeze',
'squeeze', inputs=val_x,
inputs=val_x, output=var_x0,
output=var_x0, param_attr={
param_attr={ 'axes': [1],
'axes': [1], 'name': string(var_x0)
'name': string(var_x0) })
})
var_w0 = node.layer_name + '_w0' var_w0 = node.layer_name + '_w0'
node.fluid_code.add_layer( node.fluid_code.add_layer('squeeze',
'squeeze', inputs=val_w,
inputs=val_w, output=var_w0,
output=var_w0, param_attr={
param_attr={ 'axes': [0],
'axes': [0], 'name': string(var_w0)
'name': string(var_w0) })
})
var_fc = node.layer_name + '_fc' var_fc = node.layer_name + '_fc'
var_mm = (node.layer_name + '_mm') if val_b else var_fc var_mm = (node.layer_name + '_mm') if val_b else var_fc
node.fluid_code.add_layer( node.fluid_code.add_layer('matmul',
'matmul', inputs={
inputs={ 'x': var_x0,
'x': var_x0, 'y': var_w0
'y': var_w0 },
}, output=var_mm,
output=var_mm, param_attr={
param_attr={ 'transpose_x': 0,
'transpose_x': 0, 'transpose_y': 1,
'transpose_y': 1, 'name': string(var_mm)
'name': string(var_mm) })
})
var_r0 = node.layer_name + '_r0' var_r0 = node.layer_name + '_r0'
node.fluid_code.add_layer( node.fluid_code.add_layer('squeeze',
'squeeze', inputs=val_r,
inputs=val_r, output=var_r0,
output=var_r0, param_attr={
param_attr={ 'axes': [0],
'axes': [0], 'name': string(var_r0)
'name': string(var_r0) })
})
var_r0t = node.layer_name + '_r0t' var_r0t = node.layer_name + '_r0t'
node.fluid_code.add_layer( node.fluid_code.add_layer('transpose',
'transpose', inputs=var_r0,
inputs=var_r0, output=var_r0t,
output=var_r0t, param_attr={
param_attr={ 'perm': [1, 0],
'perm': [1, 0], 'name': string(var_r0t)
'name': string(var_r0t) })
})
if val_b: if val_b:
var_bi = node.layer_name + '_bi' var_bi = node.layer_name + '_bi'
var_bh = node.layer_name + '_bh' var_bh = node.layer_name + '_bh'
node.fluid_code.add_layer( node.fluid_code.add_layer('split',
'split', inputs=val_b,
inputs=val_b, output=var_bi + ',' + var_bh,
output=var_bi + ',' + var_bh, param_attr={
param_attr={ 'axis':
'axis': 1, 1,
'split': [hidden_size * 3, hidden_size * 3], 'split':
'name': string(node.layer_name + '.b/split') [hidden_size * 3, hidden_size * 3],
}) 'name':
string(node.layer_name + '.b/split')
})
var_bi0 = node.layer_name + '_bi0' var_bi0 = node.layer_name + '_bi0'
node.fluid_code.add_layer( node.fluid_code.add_layer('squeeze',
'squeeze', inputs=var_bi,
inputs=var_bi, output=var_bi0,
output=var_bi0, param_attr={
param_attr={ 'axes': [0],
'axes': [0], 'name': string(var_bi0)
'name': string(var_bi0) })
})
node.fluid_code.add_layer('elmentwise_add',
node.fluid_code.add_layer( inputs=[var_mm, var_bi0],
'elmentwise_add', output=var_fc,
inputs=[var_mm, var_bi0], param_attr={
output=var_fc, 'axes':
param_attr={ 1,
'axes': 1, 'name':
'name': string(node.layer_name + '.i/bias') string(node.layer_name + '.i/bias')
}) })
if val_xh: if val_xh:
var_xh0 = node.layer_name + '_xh0' var_xh0 = node.layer_name + '_xh0'
node.fluid_code.add_layer( node.fluid_code.add_layer('squeeze',
'squeeze', inputs=val_xh,
inputs=val_xh, output=var_xh0,
output=var_xh0, param_attr={
param_attr={ 'axes': [1],
'axes': [1], 'name': string(var_xh0)
'name': string(var_xh0) })
})
var_y00 = node.layer_name + '_y00' var_y00 = node.layer_name + '_y00'
attr = { attr = {
...@@ -1457,29 +1503,26 @@ class ONNXOpMapper(OpMapper): ...@@ -1457,29 +1503,26 @@ class ONNXOpMapper(OpMapper):
'param_attr': string(var_r0t), 'param_attr': string(var_r0t),
'bias_attr': string(var_bh) if val_b else False, 'bias_attr': string(var_bh) if val_b else False,
} }
node.fluid_code.add_layer( node.fluid_code.add_layer('dynamic_gru',
'dynamic_gru', inputs=var_fc + ',' + str(hidden_size),
inputs=var_fc + ',' + str(hidden_size), output=var_y00,
output=var_y00, param_attr=attr)
param_attr=attr)
num_opt = len(node.layer.output) num_opt = len(node.layer.output)
if num_opt > 0 and node.layer.output[0] != '': if num_opt > 0 and node.layer.output[0] != '':
node.fluid_code.add_layer( node.fluid_code.add_layer('unsqueeze',
'unsqueeze', inputs=var_y00,
inputs=var_y00, output=node.layer.output[0],
output=node.layer.output[0], param_attr={
param_attr={ 'axes': [1, 1],
'axes': [1, 1], 'name': string(node.layer.output[0])
'name': string(node.layer.output[0]) })
})
if num_opt > 1 and node.layer.output[1] != '': if num_opt > 1 and node.layer.output[1] != '':
node.fluid_code.add_layer( node.fluid_code.add_layer('unsqueeze',
'unsqueeze', inputs=var_y00,
inputs=var_y00, output=node.layer.output[1],
output=node.layer.output[1], param_attr={
param_attr={ 'axes': [1, 1],
'axes': [1, 1], 'name': string(node.layer.output[1])
'name': string(node.layer.output[1]) })
})
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或