You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
246 lines
7.7 KiB
246 lines
7.7 KiB
/**
|
|
* Copyright 2019-2020 Huawei Technologies Co., Ltd
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#ifndef GE_OP_PAD_OPS_H
|
|
#define GE_OP_PAD_OPS_H
|
|
|
|
#include "graph/operator_reg.h"
|
|
namespace ge {
|
|
|
|
/**
|
|
*@brief Creates a tensor filled with a scalar value.
|
|
* This operation creates a tensor of shape "dims" and fills it with "value".
|
|
*
|
|
*@par Inputs:
|
|
*@li dims: A 1D tensor of types int32 or int64. Represents the shape of the output tensor.
|
|
|
|
*@li value: A 0D scalar. Specifies the value to fill the returned tensor.
|
|
* Must be one of the following types:
|
|
* float16, float32, double, int32, uint8, int16, int8, complex64, int64,
|
|
* qint8, quint8, qint32, uint16, complex128, uint32, uint64.
|
|
*
|
|
*@par Outputs:
|
|
* y: A tensor. Has the same type as "value".
|
|
*
|
|
*@par Third-party framework compatibility
|
|
*@li Compatible with the TensorFlow operator Fill.
|
|
*@li Compatible with the Caffe operator Filler.
|
|
*
|
|
*/
|
|
REG_OP(Fill)
|
|
.INPUT(dims, TensorType::IndexNumberType())
|
|
.INPUT(value, TensorType::BasicType())
|
|
.OUTPUT(y, TensorType::BasicType())
|
|
.OP_END_FACTORY_REG(Fill)
|
|
|
|
/**
|
|
*@brief Creates a tensor filled with a scalar value.
|
|
* This operation creates a tensor of shape "dims" and fills it with "value".
|
|
*
|
|
*@par Inputs:
|
|
* value: A 0D scalar for the value to fill the returned tensor. Must be one of
|
|
* the following types:
|
|
* float16, float32, uint8, int8, int16, int32, int64, quint8, qint8, qint32
|
|
*
|
|
*@par Attributes:
|
|
* dims: A tensor. Must be one of the following types:"int32"
|
|
* 1-D. Represents the shape of the output tensor.
|
|
*
|
|
*@par Outputs:
|
|
* y: A tensor. Has the same type as "value".
|
|
*
|
|
*/
|
|
REG_OP(FillD)
|
|
.INPUT(value, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT8, DT_INT16,
|
|
DT_UINT16, DT_UINT8, DT_INT32, DT_INT64,
|
|
DT_UINT32, DT_UINT64, DT_BOOL, DT_DOUBLE}))
|
|
.OUTPUT(y, TensorType({DT_FLOAT, DT_FLOAT16, DT_INT8, DT_INT16, DT_UINT16,
|
|
DT_UINT8, DT_INT32, DT_INT64, DT_UINT32,
|
|
DT_UINT64, DT_BOOL, DT_DOUBLE}))
|
|
.REQUIRED_ATTR(dims, ListInt)
|
|
.OP_END_FACTORY_REG(FillD)
|
|
|
|
/**
|
|
*@brief Broadcasts an array for a compatible shape.
|
|
* Broadcasting is the process of making arrays to have compatible shapes
|
|
* for arithmetic operations. Two shapes are compatible if for each
|
|
* dimension pair they are either equal or one of them is one. When trying
|
|
* to broadcast a Tensor to a shape, it starts with the trailing dimensions,
|
|
* and works its way forward.
|
|
*
|
|
*@par Inputs:
|
|
*@li x: A tensor.
|
|
*@li shape: A tensor of type int32.
|
|
* A 1D tensor of type int32, for the shape of the desired output.
|
|
*
|
|
*@par Outputs:
|
|
* y: A tensor. Has the same type as "x".
|
|
*
|
|
*@par Third-party framework compatibility
|
|
*Compatible with the TensorFlow operator BroadcastTo.
|
|
*
|
|
*/
|
|
REG_OP(BroadcastTo)
|
|
.INPUT(x, TensorType::BasicType())
|
|
.INPUT(shape, TensorType({DT_INT32}))
|
|
.OUTPUT(y, TensorType::BasicType())
|
|
.OP_END_FACTORY_REG(BroadcastTo)
|
|
|
|
/**
|
|
*@brief Broadcasts an array for a compatible shape.
|
|
* Broadcasting is the process of making arrays to have compatible shapes
|
|
* for arithmetic operations. Two shapes are compatible if for each
|
|
* dimension pair they are either equal or one of them is one. When trying
|
|
* to broadcast a Tensor to a shape, it starts with the trailing dimensions,
|
|
* and works its way forward.
|
|
*
|
|
*@par Inputs:
|
|
* x: A tensor. A tensor to broadcast.
|
|
*
|
|
*@par Attributes:
|
|
* shape: A tensor of type int32.
|
|
* A 1D tensor of type int32, for the shape of the desired output.
|
|
*
|
|
*@par Outputs:
|
|
* y: A tensor. Has the same type as "x".
|
|
*
|
|
*@par Third-party framework compatibility
|
|
*Compatible with the TensorFlow operator BroadcastTo.
|
|
*
|
|
*/
|
|
REG_OP(BroadcastToD)
|
|
.INPUT(x, TensorType::BasicType())
|
|
.OUTPUT(y, TensorType::BasicType())
|
|
.REQUIRED_ATTR(shape, ListInt)
|
|
.OP_END_FACTORY_REG(BroadcastToD)
|
|
|
|
/**
|
|
*@brief Pads a tensor.
|
|
|
|
*@par Inputs:
|
|
*Two inputs, including:
|
|
* @li x: A Tensor. Must be one of the following types: float16, float32, double, int32,
|
|
* uint8, int16, int8, complex64, int64, qint8, quint8, qint32, qint16, quint16, uint16,
|
|
* complex128, uint32, uint64.
|
|
* @li paddings: A Tensor of type int32 or int64.
|
|
|
|
*@par Outputs:
|
|
*y: A Tensor of the same type as "x".
|
|
|
|
*@par Third-party framework compatibility:
|
|
* Compatible with TensorFlow operator Pad.
|
|
*/
|
|
REG_OP(Pad)
|
|
.INPUT(x, TensorType::BasicType())
|
|
.INPUT(paddings, TensorType::IndexNumberType())
|
|
.OUTPUT(y, TensorType::BasicType())
|
|
.OP_END_FACTORY_REG(Pad)
|
|
|
|
/**
|
|
*@brief Pads a tensor.
|
|
|
|
*@par Inputs:
|
|
*x: A Tensor. Must be one of the following types: float16, float32, int8, uint8, int32.
|
|
|
|
*@par Attributes:
|
|
*paddings: An optional "vector<vector<int>>". Defaults to "{}".
|
|
* For each dimension D of input, paddings[D, 0] indicates how many
|
|
* values to add before the contents of tensor in that dimension,
|
|
* and paddings[D, 1] indicates how many values to add after the
|
|
* contents of tensor in that dimension.
|
|
|
|
*@par Outputs:
|
|
*y: A Tensor of the same type as "x".
|
|
|
|
*@par Third-party framework compatibility:
|
|
* Compatible with TensorFlow operator Pad.
|
|
*/
|
|
REG_OP(PadD)
|
|
.INPUT(x, TensorType({DT_FLOAT16, DT_FLOAT, DT_INT8, DT_UINT8, DT_FLOAT}))
|
|
.OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT, DT_INT8, DT_UINT8, DT_FLOAT}))
|
|
.REQUIRED_ATTR(paddings, ListListInt)
|
|
.OP_END_FACTORY_REG(PadD)
|
|
|
|
/**
|
|
*@brief Create a diagonal tensor
|
|
|
|
*@par Inputs:
|
|
*Two inputs, including:
|
|
* @li x: A mutable Tensor. Must be one of the following types:
|
|
* float16, float32, int32.
|
|
|
|
* @li assist: A mutable Tensor with rank k is at most 1,
|
|
* Has the same type as "x".
|
|
|
|
*@par Outputs:
|
|
*y: A mutable Tensor. Has the same type as "x".
|
|
|
|
*@see Diag()
|
|
*@par Third-party framework compatibility
|
|
* Compatible with the TensorFlow operator Diag.
|
|
*/
|
|
REG_OP(DiagD)
|
|
.INPUT(x, TensorType({DT_FLOAT16, DT_FLOAT, DT_INT32}))
|
|
.INPUT(assist, TensorType({DT_FLOAT16, DT_FLOAT, DT_INT32}))
|
|
.OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT, DT_INT32}))
|
|
.OP_END_FACTORY_REG(DiagD)
|
|
|
|
/**
|
|
*@brief Create a diagonal tensor
|
|
|
|
*@par Inputs:
|
|
*One input, include:
|
|
* x: A mutable Tensor with rank k, where k is at most 1. Must be one of the
|
|
* following types:
|
|
* float16, float32, double, int32, int64, complex64, complex128.
|
|
|
|
*@par Outputs:
|
|
*y: A mutable Tensor. Has the same type as "x".
|
|
|
|
*@see DiagD()
|
|
*@par Third-party framework compatibility
|
|
* Compatible with the TensorFlow operator Diag.
|
|
*/
|
|
REG_OP(Diag)
|
|
.INPUT(x, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_INT32,
|
|
DT_INT64, DT_COMPLEX64, DT_COMPLEX128}))
|
|
.OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT, DT_DOUBLE, DT_INT32,
|
|
DT_INT64, DT_COMPLEX64, DT_COMPLEX128}))
|
|
.OP_END_FACTORY_REG(Diag)
|
|
|
|
/**
|
|
*@brief Ascend Padding, pad the last dimension of input
|
|
|
|
*@par Inputs:
|
|
*One input, include:
|
|
*x: Tensor which last dimension must be 1. For example: [624000, 1].
|
|
|
|
*@par Outputs:
|
|
*y: Padding the last dimension of x to padDimSize, [624000, padDimSize].
|
|
|
|
*@par Third-party framework compatibility
|
|
* Compatible with the TensorFlow operator Diag.
|
|
*/
|
|
REG_OP(AscendPadding)
|
|
.INPUT(x, TensorType::BasicType())
|
|
.OUTPUT(y, TensorType::BasicType())
|
|
.ATTR(pad_dim_size, Int, 8)
|
|
.OP_END_FACTORY_REG(AscendPadding)
|
|
|
|
} // namespace ge
|
|
|
|
#endif //GE_OP_PAD_OPS_H
|