hummingbird
/
graphengine
Not watched
2
0
Fork 0
Code
Releases 13 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 3f3c41fd04
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3f3c41fd04'
${ noResults }
graphengine/third_party/fwkacllib/inc/ops/reduce_ops.h

362 lines
13 kB
Raw Blame History 

  1. /**

  2.  * Copyright 2019-2020 Huawei Technologies Co., Ltd

  3.  *

  4.  * Licensed under the Apache License, Version 2.0 (the "License");

  5.  * you may not use this file except in compliance with the License.

  6.  * You may obtain a copy of the License at

  7.  *

  8.  * http://www.apache.org/licenses/LICENSE-2.0

  9.  *

  10.  * Unless required by applicable law or agreed to in writing, software

  11.  * distributed under the License is distributed on an "AS IS" BASIS,

  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  13.  * See the License for the specific language governing permissions and

  14.  * limitations under the License.

  15.  */

  16. 

  17. #ifndef GE_OP_REDUCE_OPS_H

  18. #define GE_OP_REDUCE_OPS_H

  19. 

  20. #include "../graph/operator_reg.h"

  21. 

  22. namespace ge {

  23. REG_OP(BNTrainingReduce)

  24.     .INPUT(x, TensorType({DT_FLOAT16,DT_FLOAT}))

  25.     .OUTPUT(sum, TensorType({DT_FLOAT}))

  26.     .OUTPUT(square_sum, TensorType({DT_FLOAT}))

  27.     .OP_END_FACTORY_REG(BNTrainingReduce)

  28. 

  29. REG_OP(BNTrainingReduceGrad)

  30.     .INPUT(grads, TensorType({DT_FLOAT16,DT_FLOAT}))

  31.     .INPUT(x, TensorType({DT_FLOAT16,DT_FLOAT}))

  32.     .INPUT(diff_scale, TensorType({DT_FLOAT}))

  33.     .INPUT(diff_offset, TensorType({DT_FLOAT}))

  34.     .INPUT(scale, TensorType({DT_FLOAT}))

  35.     .INPUT(batch_mean, TensorType({DT_FLOAT}))

  36.     .INPUT(batch_variance, TensorType({DT_FLOAT}))

  37.     .OUTPUT(y, TensorType({DT_FLOAT16,DT_FLOAT}))

  38.     .ATTR(epsilon, Float, 0.0001)

  39.     .OP_END_FACTORY_REG(BNTrainingReduceGrad)

  40. 

  41. REG_OP(BNTrainingUpdate)

  42.     .INPUT(x, TensorType({DT_FLOAT16,DT_FLOAT}))

  43.     .INPUT(sum, TensorType({DT_FLOAT}))

  44.     .INPUT(square_sum, TensorType({DT_FLOAT}))

  45.     .INPUT(scale, TensorType({DT_FLOAT}))

  46.     .INPUT(offset, TensorType({DT_FLOAT}))

  47.     .INPUT(mean, TensorType({DT_FLOAT}))

  48.     .INPUT(variance, TensorType({DT_FLOAT}))

  49.     .REQUIRED_ATTR(factor, Float)

  50.     .REQUIRED_ATTR(epsilon, Float)

  51.     .OUTPUT(y, TensorType({DT_FLOAT16,DT_FLOAT}))

  52.     .OUTPUT(mean, TensorType({DT_FLOAT}))

  53.     .OUTPUT(variance, TensorType({DT_FLOAT}))

  54.     .OUTPUT(batch_mean, TensorType({DT_FLOAT}))

  55.     .OUTPUT(batch_variance, TensorType({DT_FLOAT}))

  56.     .OP_END_FACTORY_REG(BNTrainingUpdate)

  57. 

  58. REG_OP(BNInfer)

  59.     .INPUT(x, TensorType({DT_FLOAT16,DT_FLOAT}))

  60.     .INPUT(scale, TensorType({DT_FLOAT}))

  61.     .INPUT(offset, TensorType({DT_FLOAT}))

  62.     .INPUT(mean, TensorType({DT_FLOAT}))

  63.     .INPUT(variance, TensorType({DT_FLOAT}))

  64.     .REQUIRED_ATTR(epsilon, Float)

  65.     .OUTPUT(y, TensorType({DT_FLOAT16,DT_FLOAT}))

  66.     .OP_END_FACTORY_REG(BNInfer)

  67. 

  68. REG_OP(BNTrainingUpdateV2)

  69.     .INPUT(x, TensorType({DT_FLOAT16,DT_FLOAT}))

  70.     .INPUT(sum, TensorType({DT_FLOAT}))

  71.     .INPUT(square_sum, TensorType({DT_FLOAT}))

  72.     .INPUT(scale, TensorType({DT_FLOAT}))

  73.     .INPUT(offset, TensorType({DT_FLOAT}))

  74.     .REQUIRED_ATTR(epsilon, Float)

  75.     .OUTPUT(y, TensorType({DT_FLOAT16,DT_FLOAT}))

  76.     .OUTPUT(batch_mean, TensorType({DT_FLOAT}))

  77.     .OUTPUT(batch_variance, TensorType({DT_FLOAT}))

  78.     .OP_END_FACTORY_REG(BNTrainingUpdateV2)

  79. 

  80. REG_OP(BNTrainingUpdateGrad)

  81.     .INPUT(grads, TensorType({DT_FLOAT16,DT_FLOAT}))

  82.     .INPUT(x, TensorType({DT_FLOAT16,DT_FLOAT}))

  83.     .INPUT(batch_mean, TensorType({DT_FLOAT}))

  84.     .INPUT(batch_variance, TensorType({DT_FLOAT}))

  85.     .ATTR(epsilon, Float, 0.0001)

  86.     .OUTPUT(diff_scale, TensorType({DT_FLOAT}))

  87.     .OUTPUT(diff_offset, TensorType({DT_FLOAT}))

  88.     .OP_END_FACTORY_REG(BNTrainingUpdateGrad)

  89. 

  90. REG_OP(BNInferGrad)

  91.     .INPUT(grads, TensorType({DT_FLOAT16,DT_FLOAT}))

  92.     .INPUT(scale, TensorType({DT_FLOAT}))

  93.     .INPUT(batch_variance, TensorType({DT_FLOAT}))

  94.     .OUTPUT(x_backprop, TensorType({DT_FLOAT16,DT_FLOAT}))

  95.     .ATTR(epsilon, Float, 0.0001)

  96.     .OP_END_FACTORY_REG(BNInferGrad)

  97. 

  98. REG_OP(ReduceSum)

  99.     .INPUT(x, TensorType::NumberType())

  100.     .INPUT(axis, TensorType::IndexNumberType())

  101.     .OUTPUT(y, TensorType::NumberType())

  102.     .ATTR(keep_dims, Bool, false)

  103.     .OP_END_FACTORY_REG(ReduceSum)

  104. 

  105. REG_OP(ReduceSumD)

  106.     .INPUT(x, TensorType({DT_FLOAT16, DT_FLOAT, DT_INT8, DT_UINT8, DT_INT32}))

  107.     .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT, DT_INT8, DT_UINT8, DT_INT32}))

  108.     .REQUIRED_ATTR(axis, ListInt)

  109.     .ATTR(keep_dims, Bool, false)

  110.     .OP_END_FACTORY_REG(ReduceSumD)

  111. 

  112. /**

  113. *@brief Calculates the "logical sum" of elements of a tensor in a dimension.

  114. 

  115. *@par Inputs:

  116. *One input:

  117. *x: A mutable Tensor. Must be one of the following types: float16,

  118. * float32, double. Should be a Variable Tensor.

  119. 

  120. *@par Attributes:

  121. *@li keep_dims: A bool. If true, retains reduced dimensions with length 1.

  122. *@li axis: The dimensions to reduce. If None, reduces all dimensions.

  123. *Must be in the range [- rank (input_sensor), rank (input_sensor)).

  124. 

  125. *@par Outputs:

  126. *y: The reduced tensor.

  127. */

  128. REG_OP(ReduceAllD)

  129.     .INPUT(x, TensorType({DT_BOOL}))

  130.     .OUTPUT(y, TensorType({DT_BOOL}))

  131.     .REQUIRED_ATTR(axis, ListInt)

  132.     .ATTR(keep_dims, Bool, false)

  133.     .OP_END_FACTORY_REG(ReduceAllD)

  134. 

  135. /**

  136. *@brief Calculates the "logical sum" of elements of a tensor in a dimension.

  137. 

  138. *@par Inputs:

  139. *Two inputs, including:

  140. *@li x: A mutable Tensor. Must be one of the following types: float16, float32, double. Should be a Variable Tensor.

  141. *@li axis: A mutable Tensor. The dimensions to reduce. If None, reduces all dimensions. Must be in the range [- rank (input_sensor), rank (input_sensor)).

  142. 

  143. *@par Attributes:

  144. *keep_dims: A bool. If true, retains reduced dimensions with length 1.

  145. 

  146. *@par Outputs:

  147. *y: The reduced tensor.

  148. */

  149. REG_OP(ReduceAll)

  150.     .INPUT(x, TensorType({DT_BOOL}))

  151.     .INPUT(axis, TensorType::IndexNumberType())

  152.     .OUTPUT(y, TensorType({DT_BOOL}))

  153.     .ATTR(keep_dims, Bool, false)

  154.     .OP_END_FACTORY_REG(ReduceAll)

  155. 

  156. /**

  157. *@brief  Reduce a tensor on a certain axis based on product..

  158. 

  159. *@par Inputs:

  160. *Two inputs, including:

  161. *@li x: A mutable Tensor. Must be the type of NumberType.

  162. *@li axis: A mutable Tensor. The dimensions to reduce.

  163. 

  164. *@par Attributes:

  165. *@li keep_dims: A bool. If true, retains reduced dimensions with length 1. Defaults to "False".

  166. 

  167. *@par Outputs:

  168. *y: A Tensor. Has the same type and format as input "x".

  169. */

  170. REG_OP(ReduceProd)

  171.     .INPUT(x,TensorType::NumberType())

  172.     .INPUT(axis, TensorType::IndexNumberType())

  173.     .OUTPUT(y,TensorType::NumberType())

  174.     .ATTR(keep_dims, Bool, false)

  175.     .OP_END_FACTORY_REG(ReduceProd)

  176. 

  177. /**

  178. *@brief Computes the product of elements across dimensions of a tensor.

  179. 

  180. *@par Inputs:

  181. * One input: \n

  182. *x: A Tensor. Must be one of the following types: float16, float, int8, uint8.

  183. 

  184. *@par Attributes:

  185. *@li axis: A required int8, int16, int32, or int64. Specifies the dimensions to reduce. No default value.

  186. *@li keep_dims: An optional bool. If "True", retains reduced dimensions with length 1. Defaults to "False".

  187. 

  188. *@par Outputs:

  189. *y: A Tensor. Has the same type and format as input "x".

  190. 

  191. *@attention Constraints:

  192. * "keep_dims" is in the range [-rank(input_tensor), rank(input_tensor)].

  193. */

  194. REG_OP(ReduceProdD)

  195.     .INPUT(x,TensorType({DT_FLOAT, DT_UINT8, DT_INT8, DT_INT32, DT_FLOAT16}))

  196.     .OUTPUT(y,TensorType({DT_FLOAT, DT_UINT8, DT_INT8, DT_INT32, DT_FLOAT16}))

  197.     .REQUIRED_ATTR(axis, ListInt)

  198.     .ATTR(keep_dims, Bool, false)

  199.     .OP_END_FACTORY_REG(ReduceProdD)

  200. 

  201. /**

  202. *@brief Reduces "x" along the dimensions according to "axis".

  203. 

  204. *@par Inputs:

  205. *Two inputs, including:

  206. * @li x: A Tensor. Must be one of the following types: float16, float32, int8, uint8.

  207. * @li axis: The dimensions to reduce. Must be one of the following types: int, list, tuple, NoneType.\n

  208. *   - If None (the default), reduces all dimensions.\n

  209. *   - Must be in the range [-rank(x), rank(x)).

  210. 

  211. *@par Attributes:

  212. *keep_dims: A bool or NoneType. \n

  213. * - If true, retains reduced dimensions with length 1. \n

  214. * - If false, the rank of the tensor is reduced by 1 for each entry in axis.

  215. *@par Outputs:

  216. *y: A Tensor. Has the same type as "x".

  217. */

  218. REG_OP(ReduceMean)

  219.     .INPUT(x, TensorType::NumberType())

  220.     .INPUT(axis, TensorType::IndexNumberType())

  221.     .OUTPUT(y, TensorType::NumberType())

  222.     .ATTR(keep_dims, Bool, false)

  223.     .OP_END_FACTORY_REG(ReduceMean)

  224. 

  225. /**

  226. *@brief Reduces "x" along the dimensions according to "axis".

  227. 

  228. *@par Inputs:

  229. *One input:

  230. * @li x: A Tensor. Must be one of the following types: float16, float32, int8, uint8.

  231. 

  232. *@par Attributes:

  233. *@li axis: The dimensions to reduce. Must be one of the following types: int, list, tuple, NoneType. \n

  234. * If None (the default), reduces all dimensions. \n

  235. * Must be in the range [-rank(x), rank(x)). \n

  236. *@li keep_dims: A bool or NoneType. \n

  237. * - If true, retains reduced dimensions with length 1. \n

  238. * - If false, the rank of the tensor is reduced by 1 for each entry in axis.

  239. *@par Outputs:

  240. *y: A Tensor. Has the same type as "x".

  241. */

  242. REG_OP(ReduceMeanD)

  243.     .INPUT(x, TensorType({DT_FLOAT16, DT_INT32, DT_FLOAT, DT_INT8, DT_UINT8}))

  244.     .OUTPUT(y, TensorType({DT_FLOAT16, DT_INT32, DT_FLOAT, DT_INT8, DT_UINT8}))

  245.     .REQUIRED_ATTR(axis, ListInt)

  246.     .ATTR(keep_dims, Bool, false)

  247.     .OP_END_FACTORY_REG(ReduceMeanD)

  248. 

  249. REG_OP(ReduceMax)

  250.     .INPUT(x, TensorType::NumberType())

  251.     .INPUT(axis, TensorType::IndexNumberType())

  252.     .OUTPUT(y, TensorType::NumberType())

  253.     .ATTR(keep_dims, Bool, false)

  254.     .OP_END_FACTORY_REG(ReduceMax)

  255. 

  256. /**

  257. *@brief Returns the maximum of elements across dimensions of a Tensor.

  258. 

  259. *@par Inputs:

  260. *x: A multi-dimensional Tensor of type float16, float32, or int16.

  261. 

  262. *@par Attributes:

  263. * Two attributes, including: \n

  264. *@li axis: A required listint, specifying the axis information of the index with the maximum value.

  265. *@li keep_dims: A bool, specifying whether to keep dimensions for the output Tensor. Defaults to "false".

  266. 

  267. *@par Outputs:

  268. *y: A multi-dimensional Tensor, specifying the maximum value of the corresponding axis in the tensor. Has the same type as "x". (If "keep_dims" is set to "false", the output dimensions are reduced by "dimension" compared with that of "x". Otherwise, the output has one fewer dimension than "x".)

  269. 

  270. *@attention Constraints:

  271. * The value range of "axis" is [-dims, dims - 1]. "dims" indicates the dimension length of "x".

  272. */

  273. REG_OP(ReduceMaxD)

  274.     .INPUT(x, TensorType({DT_FLOAT, DT_UINT8, DT_INT8,

  275.                           DT_FLOAT16, DT_INT32}))

  276.     .OUTPUT(y, TensorType({DT_FLOAT, DT_UINT8, DT_INT8,

  277.                            DT_FLOAT16, DT_INT32}))

  278.     .REQUIRED_ATTR(axis, ListInt)

  279.     .ATTR(keep_dims, Bool, false)

  280.     .OP_END_FACTORY_REG(ReduceMaxD)

  281. 

  282. REG_OP(ReduceMin)

  283.     .INPUT(x, TensorType::NumberType())

  284.     .INPUT(axis, TensorType::IndexNumberType())

  285.     .OUTPUT(y, TensorType::NumberType())

  286.     .ATTR(keep_dims, Bool, false)

  287.     .OP_END_FACTORY_REG(ReduceMin)

  288. 

  289. REG_OP(ReduceMinD)

  290.     .INPUT(x, TensorType({DT_FLOAT16,DT_FLOAT,DT_INT8,DT_UINT8}))

  291.     .OUTPUT(y, TensorType({DT_FLOAT16,DT_FLOAT,DT_INT8,DT_UINT8}))

  292.     .REQUIRED_ATTR(axis, ListInt)

  293.     .ATTR(keep_dims, Bool, false)

  294.     .OP_END_FACTORY_REG(ReduceMinD)

  295. /**

  296. *@brief Computes the "logical or" of elements across dimensions of a tensor.\n

  297. * Reduces `x` along the dimensions given in `axis`.

  298. * Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each

  299. * entry in `axis`. If `keep_dims` is true, the reduced dimensions

  300. * are retained with length 1.

  301. *

  302. * If `axis` is None, all dimensions are reduced, and a

  303. * tensor with a single element is returned.

  304. *

  305. *@attention Constraints:\n

  306. * Only support bool

  307. *

  308. *@par Inputs:

  309. *@li x : The boolean tensor to reduce.

  310. *@li axis : The dimensions to reduce. If `None` (the default), reduces all

  311. *          dimensions. Must be in the range `[-rank(x), rank(x))`.

  312. *

  313. *@par Attributes:

  314. * keep_dims : If true, retains reduced dimensions with length 1.

  315. *

  316. *@par Outputs:

  317. * y : The reduced tensor

  318. *

  319. */

  320. REG_OP(ReduceAny)

  321.     .INPUT(x, TensorType({DT_BOOL}))

  322.     .INPUT(axis, TensorType::IndexNumberType())

  323.     .OUTPUT(y, TensorType({DT_BOOL}))

  324.     .ATTR(keep_dims, Bool, false)

  325.     .OP_END_FACTORY_REG(ReduceAny)

  326. /**

  327. *@brief Computes the "logical or" of elements across dimensions of a tensor.\n

  328. * Reduces `x` along the dimensions given in `axis`.

  329. * Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each

  330. * entry in `axis`. If `keep_dims` is true, the reduced dimensions

  331. * are retained with length 1.

  332. *

  333. * If `axis` is None, all dimensions are reduced, and a

  334. * tensor with a single element is returned.

  335. *

  336. *@attention Constraints:\n

  337. *  Only support bool

  338. *

  339. *@par Inputs:

  340. * x : The boolean tensor to reduce.

  341. *

  342. *@par Attributes:

  343. *@li axis : The dimensions to reduce. If `None` (the default), reduces all

  344. *          dimensions. Must be in the range `[-rank(x), rank(x))`.

  345. *@li keep_dims : If true, retains reduced dimensions with length 1.

  346. *

  347. *@par Outputs:

  348. * y : The reduced tensor

  349. *

  350. */

  351. REG_OP(ReduceAnyD)

  352.     .INPUT(x, TensorType({DT_BOOL}))

  353.     .OUTPUT(y, TensorType({DT_BOOL}))

  354.     .REQUIRED_ATTR(axis, ListInt)

  355.     .ATTR(keep_dims, Bool, false)

  356.     .OP_END_FACTORY_REG(ReduceAnyD)

  357. 

  358. } //namespace ge

  359. 

  360. 

  361. #endif /* GE_OP_REDUCE_OPS_H */