diff --git a/x2paddle/op_mapper/onnx2paddle/opsets/_shape_inference.py b/x2paddle/op_mapper/onnx2paddle/opsets/_shape_inference.py deleted file mode 100644 index db5aca3628107ee34b92db4f536117c58853473e..0000000000000000000000000000000000000000 --- a/x2paddle/op_mapper/onnx2paddle/opsets/_shape_inference.py +++ /dev/null @@ -1,599 +0,0 @@ -# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License" -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -from x2paddle.decoder.onnx_decoder import ONNXGraph, ONNXGraphNode, ONNXGraphDataNode -import numpy as np -import sympy - - -def handle_negative_axis(axis, rank): - return axis if axis >= 0 else axis + rank - - -class ShapeInference(): - def __init__(self, decoder, auto_merge=False): - self.decoder = decoder - self.fluid_data = {} - self.suggested_merge_ = {} - self.symbolic_dims_ = {} - self.auto_merge_ = auto_merge - self.dispatcher = { - # activation ops - 'Relu': self.activation_ops, - 'LeakyRelu': self.activation_ops, - 'Elu': self.activation_ops, - 'ThresholdRelu': self.activation_ops, - 'Prelu': self.activation_ops, - 'Tanh': self.activation_ops, - 'Sigmoid': self.activation_ops, - 'Softplus': self.activation_ops, - 'Softsign': self.activation_ops, - 'HardSigmoid': self.activation_ops, - 'Shrink': self.activation_ops, - 'Exp': self.activation_ops, - 'Clip': self.activation_ops, - - # elementwise ops - 'Add': self.elementwise_ops, - 'Div': self.elementwise_ops, - 'Sub': self.elementwise_ops, - 'Mul': self.elementwise_ops, - 'Pow': self.elementwise_ops, - 'Sqrt': self.elementwise_ops, - 'Softmax': self.elementwise_ops, - 'Constant': self.constant, - 'AveragePool': self.pool, - 'MaxPool': self.pool, - 'Cast': self.cast, - 'Conv': self.conv, - 'BatchNormalization': self.batch_norm, - 'Pad': self.pad, - 'Gather': self.gather, - 'Split': self.split, - 'Transpose': self.transpose, - 'Reshape': self.reshape, - 'MatMul': self.matmul, - 'Squeeze': self.squeeze, - 'Unsqueeze': self.unsqueeze, - 'Concat': self.concat, - } - self.run_ = True - self.suggested_merge_ = {} - self.symbolic_dims_ = {} - self.input_symbols_ = {} - - def __call__(self): - """ - run shape inference - """ - nodes = self.decoder.model.graph.node - node_map = self.decoder.onnx_graph.node_map - value_infos = self.decoder.onnx_graph.value_infos - onnx_model = self.decoder.model - #self._apply_suggested_merge(graph_input_only=True) - for layer in nodes: - node = node_map[layer.name] - for opt in layer.output: - if opt in value_infos: - value_info = value_infos[opt] - #if len(value_info['shape']) == 0 or value_info[ - # 'dtype'] is None or 0 in value_info['shape']: - # #TODO add node shape inference - # if self.is_support_inference(node): - # op_infer = self.dispatcher[node.layer_type] - # #shapes = op_infer(node) - # print(node.layer_name + ': ') - # print(node.layer_type + ': ') - #else: - # print(node.layer_name) - node.dtype = value_info['dtype'] - node.out_shapes.append(value_info['shape']) - else: - #TODO add node shape inference - if self.is_support_inference(node): - op_infer = self.dispatcher[node.layer_type] - #shapes = op_infer(node) - #print(node.layer_name + ': ') - #print(node.layer_type + ': ') - - def get_input_node(self, node, idx, copy=False): - return self.decoder.onnx_graph.get_input_node(node, idx=idx, copy=copy) - - def get_fluid_data(self, node, return_ndarray=False): - data = None - if node.layer_name in self.fluid_data: - data = self.fluid_data[node.layer_name] - elif isinstance(node, ONNXGraphDataNode): - data = node.weight - elif isinstance(node, ONNXGraphNode): - data = node.value - if return_ndarray: - return data - else: - return data.tolist() - - def is_support_inference(self, node): - if node.layer_type not in self.dispatcher: - print( - "[WARNNING] Shape inference not support Node[{}](op type: {}) ". - format(node.layer_name, node.layer_type)) - return False - return True - - def _try_get_value(self, node, idx): - if idx >= len(node.inputs): - return None - return self.get_input_node(node, idx=idx, return_ndarray=True) - - def _get_int_values(self, node, broadcast=False): - values = [self._try_get_value(node, i) for i in range(len(node.input))] - if all([v is not None for v in values]): - # some shape compute is in floating point, cast to int for sympy - for i, v in enumerate(values): - if type(v) != np.ndarray: - continue - if len(v.shape) > 1: - new_v = None # ignore value for rank > 1 - elif len(v.shape) == 0: - new_v = int(np.asscalar(v)) - else: - assert len(v.shape) == 1 - new_v = [int(vv) for vv in v] - values[i] = new_v - values_len = [len(v) if type(v) == list else 0 for v in values] - max_len = max(values_len) - if max_len >= 1 and broadcast: - # broadcast - for i, v in enumerate(values): - if v is None: - continue # don't broadcast if value is unknown - if type(v) == list: - if len(v) < max_len: - values[i] = v * max_len - else: - assert len(v) == max_len - else: - values[i] = [v] * max_len - return values - - def _compute_on_sympy_data(self, node, op_func): - assert len(node.outputs) == 1 - values = self._get_int_values(node, broadcast=True) - if all([v is not None for v in values]): - is_list = [type(v) == list for v in values] - as_list = any(is_list) - if as_list: - data = [op_func(vs) for vs in zip(*values)] - self.fluid_data[node.layer_name] = data - node.out_shapes.append(data.shape) - print('*' * 10, data) - else: - data = op_func(values) - self.fluid_data[node.layer_name] = data - print('*' * 10, data) - node.out_shapes.append(data.shape) - - def _pass_on_sympy_data(self, node): - assert len(node.inputs) == 1 or node.layer_type == 'Reshape' - self._compute_on_sympy_data(node, lambda x: x[0]) - - def _get_sympy_shape(self, node, idx): - sympy_shape = [] - for d in self._get_shape(node, idx): - if type(d) == str: - sympy_shape.append(self.symbolic_dims_[d] if d in - self.symbolic_dims_ else sympy.Symbol( - d, integer=True)) - else: - assert None != d - sympy_shape.append(d) - return sympy_shape - - def _check_merged_dims(self, dims, allow_broadcast=True): - if allow_broadcast: - dims = [d for d in dims if not (is_literal(d) and int(d) <= 1)] - if not all([d == dims[0] for d in dims]): - self._add_suggested_merge(dims, apply=True) - - def check_specific_shape(self, input_node, output_node, shape): - if -1 in input_node.out_shapes[0]: - assert "Shape inference failed, when calculate output_node[{}]'s \ - shape need specific shape, but got input_node[{}]'s shape: {}".format( - output_node.layer_name, input_node.layer_name, - input_node.out_shapes[0]) - - def _add_suggested_merge(self, symbols, apply=False): - assert all([(type(s) == str and s in self.symbolic_dims_) or - is_literal(s) for s in symbols]) - symbols = set(symbols) - for k, v in self.suggested_merge_.items(): - if k in symbols: - symbols.remove(k) - symbols.add(v) - map_to = None - # if there is literal, map to it first - for s in symbols: - if is_literal(s): - map_to = s - break - # when no literals, map to input symbolic dims, then existing symbolic dims - if map_to is None: - for s in symbols: - if s in self.input_symbols_: - map_to = s - break - if map_to is None: - for s in symbols: - if type(self.symbolic_dims_[s]) == sympy.Symbol: - map_to = s - break - # when nothing to map to, use the shorter one - if map_to is None: - if self.verbose_ > 0: - print( - 'Potential unsafe merge between symbolic expressions: ({})'. - format(','.join(symbols))) - symbols_list = list(symbols) - lens = [len(s) for s in symbols_list] - map_to = symbols_list[lens.index(min(lens))] - symbols.remove(map_to) - - def _merge_symbols(self, dims): - if not all([type(d) == str for d in dims]): - if self.auto_merge_: - assert len( - dims - ) == 2 # only allow symbol->int merge in binary ops for now - is_int = [is_literal(d) for d in dims] - if sum(is_int) == 1: - int_dim = is_int.index(1) - if self.verbose_ > 0: - print('dim {} has been merged with value {}'.format( - dims[1 - int_dim], dims[int_dim])) - self._check_merged_dims(dims, allow_broadcast=False) - return dims[int_dim] - else: - if self.verbose_ > 0: - print('dim {} has been mergd with dim {}'.format(dims[ - 0], dims[1])) - return dims[0] - else: - return None - if all([d == dims[0] for d in dims]): - return dims[0] - merged = [ - self.suggested_merge_[d] if d in self.suggested_merge_ else d - for d in dims - ] - if all([d == merged[0] for d in merged]): - assert merged[0] in self.symbolic_dims_ - return merged[0] - else: - return None - - # broadcast from right to left, and merge symbolic dims if needed - def _broadcast_shapes(self, shape1, shape2): - new_shape = [] - rank1 = len(shape1) - rank2 = len(shape2) - new_rank = max(rank1, rank2) - for i in range(new_rank): - dim1 = shape1[rank1 - 1 - i] if i < rank1 else 1 - dim2 = shape2[rank2 - 1 - i] if i < rank2 else 1 - if dim1 == 1 or dim1 == dim2: - new_dim = dim2 - elif dim2 == 1: - new_dim = dim1 - else: - new_dim = self._merge_symbols([dim1, dim2]) - if not new_dim: - # warning about unsupported broadcast when not auto merge - # note that auto merge has the risk of incorrectly merge symbols while one of them being 1 - # for example, 'a' = 1, 'b' = 5 at runtime is valid broadcasting, but with auto merge 'a' == 'b' - if self.auto_merge_: - self._add_suggested_merge([dim1, dim2], apply=True) - else: - print('unsupported broadcast between ' + str(dim1) + ' ' - + str(dim2)) - new_shape = [new_dim] + new_shape - return new_shape - - def _apply_suggested_merge(self, graph_input_only=False): - if not self.suggested_merge_: - return - for i in list(self.decoder.model.graph.input) + ( - [] if graph_input_only else - list(self.decoder.model.graph.value_info)): - for d in i.type.tensor_type.shape.dim: - if d.dim_param in self.suggested_merge_: - v = self.suggested_merge_[d.dim_param] - if is_literal(v): - d.dim_value = int(v) - else: - d.dim_param = v - - def _add_suggested_merge(self, symbols, apply=False): - assert all([(type(s) == str and s in self.symbolic_dims_) or - is_literal(s) for s in symbols]) - symbols = set(symbols) - for k, v in self.suggested_merge_.items(): - if k in symbols: - symbols.remove(k) - symbols.add(v) - map_to = None - # if there is literal, map to it first - for s in symbols: - if is_literal(s): - map_to = s - break - # when no literals, map to input symbolic dims, then existing symbolic dims - if map_to is None: - for s in symbols: - if s in self.input_symbols_: - map_to = s - break - if map_to is None: - for s in symbols: - if type(self.symbolic_dims_[s]) == sympy.Symbol: - map_to = s - break - # when nothing to map to, use the shorter one - if map_to is None: - if self.verbose_ > 0: - print( - 'Potential unsafe merge between symbolic expressions: ({})'. - format(','.join(symbols))) - symbols_list = list(symbols) - lens = [len(s) for s in symbols_list] - map_to = symbols_list[lens.index(min(lens))] - symbols.remove(map_to) - - for s in symbols: - if s == map_to: - continue - if is_literal(map_to) and is_literal(s): - assert int(map_to) == int(s) - self.suggested_merge_[s] = int(map_to) if is_literal( - map_to) else map_to - for k, v in self.suggested_merge_.items(): - if v == s: - self.suggested_merge_[k] = map_to - if apply and self.auto_merge_: - self._apply_suggested_merge() - - def pool_conv_ops(self, node): - fluid_shape = self.get_input_node(node, idx=0).out_shapes[0] - if len(node.inputs) > 1: - W_shape = self.get_input_node(node, idx=1).out_shapes[0] - rank = len(W_shape) - 2 # number of spatial axes - kernel_shape = W_shape[-rank:] - sympy_shape[1] = W_shape[0] - else: - W_shape = None - kernel_shape = node.get_attr('kernel_shape') - rank = len(kernel_shape) - dilations = node.get_attr('dilations', [1] * rank) - strides = node.get_attr('strides', [1] * rank) - pads = node.get_attr('pads') - effective_kernel_shape = [(k - 1) * d + 1 - for k, d in zip(kernel_shape, dilations)] - if pads is None: - pads = [0] * (2 * rank) - auto_pad = node.get_attr('auto_pad', b'NOTSET').decode('utf-8') - if auto_pad != 'VALID' and auto_pad != 'NOTSET': - try: - residual = [ - sympy.Mod(d, s) - for d, s in zip(fluid_shape[-rank:], strides) - ] - total_pads = [ - max(0, (k - s) if r == 0 else (k - r)) - for k, s, r in zip(effective_kernel_shape, strides, - residual) - ] - except TypeError: # sympy may throw TypeError: cannot determine truth value of Relational - total_pads = [ - max(0, (k - s)) - for k, s in zip(effective_kernel_shape, strides) - ] # assuming no residual if sympy throws error - elif auto_pad == 'VALID': - total_pads = [] - else: - total_pads = [0] * rank - else: - assert len(pads) == 2 * rank - total_pads = [p1 + p2 for p1, p2 in zip(pads[:rank], pads[rank:])] - ceil_mode = node.get_attr('ceil_mode', 0) - for i in range(rank): - effective_input_size = fluid_shape[-rank + i] - if len(total_pads) > 0: - effective_input_size = effective_input_size + total_pads[i] - if ceil_mode: - strided_kernel_positions = sympy.ceiling( - (effective_input_size - effective_kernel_shape[i]) / - strides[i]) - else: - strided_kernel_positions = ( - effective_input_size - effective_kernel_shape[i] - ) // strides[i] - fluid_shape[-rank + i] = strided_kernel_positions + 1 - node.out_shapes.append(fluid_shape) - return fluid_shape - - def cast(self, node): - fluid_shape = self.get_input_node(node, idx=0).out_shape[0] - node.out_shapes.append(fluid_shape) - return fluid_shape - - def pool(self, node): - return self.conv_pool_ops(node) - - def conv(self, node): - return self.conv_pool_ops(node) - - def batch_norm(self, node): - fluid_shape = self.get_input_node(node, idx=0).out_shapes[0] - node.out_shapes.append(fluid_shape) - return fluid_shape - - def activation_ops(self, node): - fluid_shape = self.get_input_node(node, idx=0).out_shapes[0] - node.out_shapes.append(fluid_shape) - return fluid_shape - - def elementwise_ops(self, node): - fluid_shape = self.get_input_node(node, idx=0).out_shapes[0] - node.out_shapes.append(fluid_shape) - return fluid_shape - - def pad(self, node): - fluid_shape = self.get_input_node(node, idx=0).out_shapes[0] - # op_set <= 10 - pads = node.get_attr('pads') - - rank = len(fluid_shape) - fluid_shape = [ - d + pad_up + pad_down - for d, pad_up, pad_down in zip(fluid_shape, pads[:rank], pads[ - rank:]) - ] - node.out_shapes.append(fluid_shape) - return fluid_shape - - def gather(self, node): - fluid_shape = self.get_input_node(node, idx=0).out_shapes[0] - axis = handle_negative_axis(node.get_attr('axis', 0), len(fluid_shape)) - indices_shape = self.get_input_node(node, idx=1).out_shapes[0] - fluid_shape = fluid_shape[:axis] + list(indices_shape) + fluid_shape[ - axis + 1:] - input = self.get_input_node(node, 0) - if input.layer_name in self.fluid_data: - assert 0 == axis # only handle 1D sympy compute - idx = self.get_fluid_date(indices_shape) - data = self.fluid_data[input.layer_name] - if type(data) == list: - if type(idx) == np.ndarray and len(idx.shape) == 1: - self.fluid_data[ - node.layer_name] = [data[int(i)] for i in idx] - else: - self.fluid_data[node.layer_name] = data[int(idx)] - else: - assert idx == 0 - self.fluid_data[node.layer_name] = data - - node.out_shapes.append(fluid_shape) - return fluid_shape - - def constant(self, node): - if isinstance(node, ONNXGraphNode): - fluid_shape = node.value.shape - else: - fluid_shape = node.weight.shape - - node.out_shapes.append(fluid_shape) - return fluid_shape - - def split(self, node): - fluid_shape = self.get_input_node(node, idx=0).out_shapes[0] - axis = handle_negative_axis(node.get_attr('axis', 0), len(fluid_shape)) - split = node.get_attr('split') - - if not split: - num_outputs = len(node.outputs) - split = [fluid_shape[axis] / - sympy.Integer(num_outputs)] * num_outputs - else: - split = [sympy.Integer(s) for s in split] - shapes = [] - for i_o in range(len(split)): - shape = fluid_shape[:axis] + [split[i_o]] + fluid_shape[axis + 1:] - shapes.append(shape) - node.out_shapes += shapes - - return shapes - - def shape(self, node): - fluid_shape = self.get_input_node(node, idx=0).out_shapes[0] - fluid_shape = [len(fluid_shape), ] - node.out_shapes.append(fluid_shape) - self.fluid_data[node.layer_name] = np.array(fluid_shape) - return fluid_shape - - def transpose(self, node): - fluid_shape = self.get_input_node(node, idx=0).out_shapes[0] - perm = node.get_attr('perm') - fulid_shape = np.array(fluid_shape)[perm].tolist() - node.out_shapes.append(fluid_shape) - return fluid_shape - - def reshape(self, node): - shape = self.get_input_node(node, idx=1) - shape_data = self.get_fluid_data(shape) - if shape_data is not None: - if -1 in shape_data: - fluid_shape = self.get_input_node(node, idx=0).out_shapes[0] - print(fluid_shape) - index = shape_data.index(-1) - total_elements = 1 - for dim in fluid_shape: - total_elements *= dim - part_elements = 1 - for dim in shape_data: - if dim != -1: - part_elements *= dim - shape_data[index] = total_elements // part_elements - node.out_shapes.append(shape_data) - else: - pass - return shape_data - - def matmul(self, node): - x_shape = self.get_input_node(node, idx=0).out_shapes[0] - y_shape = self.get_input_node(node, idx=1).out_shapes[0] - x_rank = len(x_shape) - y_rank = len(y_shape) - if x_rank == 1 and y_rank == 1: - new_shape = [] - elif x_rank == 1: - y_reduce_dim = -2 - new_shape = x_shape[:y_reduce_dim] + [x_shape[-1]] - elif y_rank == 1: - x_reduce_dim = -1 - new_shape = x_shape[:x_reduce_dim] - else: - x_reduce_dim = -1 - y_reduce_dim = -2 - new_shape = self._broadcast_shapes( - x_shape[:-2], y_shape[:-2]) + [x_shape[-2]] + [y_shape[-1]] - node.out_shapes.append(new_shape) - return new_shape - - def squeeze(self, node): - self._pass_on_sympy_data(node) - - def unsqueeze(self, node): - self._pass_on_sympy_data(node) - - def concat(self, node): - if any([i in self.fluid_data for i in node.inputs]): - values = self._get_int_values(node) - if all([v is not None for v in values]): - assert 0 == get_attribute(node, 'axis') - self.fluid_data[node.layer_name] = [] - for i in range(len(node.input)): - value = values[i] - if type(value) == list: - self.fluid_data[node.layer_name].extend(value) - else: - self.fluid_data[node.layer_name].append(value) diff --git a/x2paddle/op_mapper/paddle2onnx/opset10/paddle_custom_layer/im2sequence.py b/x2paddle/op_mapper/paddle2onnx/opset10/paddle_custom_layer/im2sequence.py index 3f4d8932008f1649969f87b5e1eebb7dfea12f57..84144ca1fdacbc18cc640370352b0ff726b45f0b 100644 --- a/x2paddle/op_mapper/paddle2onnx/opset10/paddle_custom_layer/im2sequence.py +++ b/x2paddle/op_mapper/paddle2onnx/opset10/paddle_custom_layer/im2sequence.py @@ -1,3 +1,17 @@ +# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License" +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + import onnx import numpy as np from onnx import onnx_pb, helper diff --git a/x2paddle/op_mapper/paddle2onnx/opset10/paddle_custom_layer/yolo_box.py b/x2paddle/op_mapper/paddle2onnx/opset10/paddle_custom_layer/yolo_box.py index aed4e49385c213aa6b201a3a82de9a72d233c642..563c5b1db2f57f99eeb1c29efad687bc5a0cfab1 100644 --- a/x2paddle/op_mapper/paddle2onnx/opset10/paddle_custom_layer/yolo_box.py +++ b/x2paddle/op_mapper/paddle2onnx/opset10/paddle_custom_layer/yolo_box.py @@ -1,3 +1,17 @@ +# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License" +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + import onnx import numpy as np from onnx import onnx_pb, helper diff --git a/x2paddle/op_mapper/paddle2onnx/opset11/opset.py b/x2paddle/op_mapper/paddle2onnx/opset11/opset.py index 7bca0c0c567e2401b9ea82baaea6ea14aee4343f..839fd4f48f86d14f3dd1e3a4e132a4b6263a6706 100644 --- a/x2paddle/op_mapper/paddle2onnx/opset11/opset.py +++ b/x2paddle/op_mapper/paddle2onnx/opset11/opset.py @@ -1,4 +1,4 @@ -# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved. +# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License" # you may not use this file except in compliance with the License. diff --git a/x2paddle/op_mapper/paddle2onnx/opset11/paddle_custom_layer/im2sequence.py b/x2paddle/op_mapper/paddle2onnx/opset11/paddle_custom_layer/im2sequence.py index b4e2fd80150f7746833886d1b731f18801685f70..be7aa3423d06c781413a87a9ca37cafb9bda5af4 100644 --- a/x2paddle/op_mapper/paddle2onnx/opset11/paddle_custom_layer/im2sequence.py +++ b/x2paddle/op_mapper/paddle2onnx/opset11/paddle_custom_layer/im2sequence.py @@ -1,3 +1,17 @@ +# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License" +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + import onnx import numpy as np from onnx import onnx_pb, helper diff --git a/x2paddle/op_mapper/paddle2onnx/opset11/paddle_custom_layer/yolo_box.py b/x2paddle/op_mapper/paddle2onnx/opset11/paddle_custom_layer/yolo_box.py index b9375c232c78e10f10d10ebe24fdd0e4ac09f9a3..5e674d5217693227d4eec33b58f7d252296947f1 100644 --- a/x2paddle/op_mapper/paddle2onnx/opset11/paddle_custom_layer/yolo_box.py +++ b/x2paddle/op_mapper/paddle2onnx/opset11/paddle_custom_layer/yolo_box.py @@ -1,3 +1,17 @@ +# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License" +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + import onnx import numpy as np from onnx import onnx_pb, helper diff --git a/x2paddle/op_mapper/paddle2onnx/opset9/opset.py b/x2paddle/op_mapper/paddle2onnx/opset9/opset.py index 13971709e12c95f08341a391a4103949447c4811..75988fae22d97f134ee826a7b5ce5ace93e08d0a 100644 --- a/x2paddle/op_mapper/paddle2onnx/opset9/opset.py +++ b/x2paddle/op_mapper/paddle2onnx/opset9/opset.py @@ -1,4 +1,4 @@ -# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved. +# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License" # you may not use this file except in compliance with the License. diff --git a/x2paddle/op_mapper/paddle2onnx/opset9/paddle_custom_layer/im2sequence.py b/x2paddle/op_mapper/paddle2onnx/opset9/paddle_custom_layer/im2sequence.py index aeb4a9ceddb280295aafb2ebcafa3a25f8767d75..ab5a90d3b2a64f5c61fad957c0f0c4e1835bb165 100644 --- a/x2paddle/op_mapper/paddle2onnx/opset9/paddle_custom_layer/im2sequence.py +++ b/x2paddle/op_mapper/paddle2onnx/opset9/paddle_custom_layer/im2sequence.py @@ -1,3 +1,17 @@ +# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License" +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + import onnx import numpy as np from onnx import onnx_pb, helper diff --git a/x2paddle/op_mapper/paddle2onnx/opset9/paddle_custom_layer/multiclass_nms.py b/x2paddle/op_mapper/paddle2onnx/opset9/paddle_custom_layer/multiclass_nms.py index 1e8cad131c445300d7660bcf9bfb9a95adf2446d..58d8e0c9d1c9e780b62cfba578973512e1214ba8 100644 --- a/x2paddle/op_mapper/paddle2onnx/opset9/paddle_custom_layer/multiclass_nms.py +++ b/x2paddle/op_mapper/paddle2onnx/opset9/paddle_custom_layer/multiclass_nms.py @@ -1,4 +1,4 @@ -# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved. +# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License" # you may not use this file except in compliance with the License. diff --git a/x2paddle/op_mapper/paddle2onnx/opset9/paddle_custom_layer/yolo_box.py b/x2paddle/op_mapper/paddle2onnx/opset9/paddle_custom_layer/yolo_box.py index a1e49e77b32ce1d64c11ca35ac69ed6cb20ee51c..c1a37030302b94a111a019c3c8713cdbc1b02364 100644 --- a/x2paddle/op_mapper/paddle2onnx/opset9/paddle_custom_layer/yolo_box.py +++ b/x2paddle/op_mapper/paddle2onnx/opset9/paddle_custom_layer/yolo_box.py @@ -1,3 +1,17 @@ +# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License" +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + import onnx import numpy as np from onnx import onnx_pb, helper