Huawei_Technology
/
mindspore
Not watched
1
0
Fork 0
Code
Releases 13 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
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: 7ffb8bb19f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '7ffb8bb19f'
${ noResults }
mindspore/mindspore/ccsrc/transform/op_declare.cc

1257 lines
54 kB
Raw Blame History 

  1. /**

  2.  * Copyright 2019 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. #include "transform/op_declare.h"

  18. 

  19. #include <vector>

  20. 

  21. #include "transform/all_ops.h"

  22. #include "utils/utils.h"

  23. 

  24. namespace mindspore {

  25. namespace transform {

  26. #define INPUT_MAP(T) \

  27.   template <>        \

  28.   const std::unordered_map<int, InputDesc> OpAdapter<T>::input_map_

  29. #define EMPTY_INPUT_MAP std::unordered_map<int, InputDesc>()

  30. #define INPUT_DESC(name) \

  31.   {                      \

  32. #name, \

  33.     [](const OperatorPtr op, const OperatorPtr input) { \

  34.         auto p = std::static_pointer_cast<OpType>(op); \

  35.         (void)p->set_input_##name(*input); \

  36.     }, \

  37.     [](const OperatorPtr op, const OutHandler& handle) { \

  38.         auto p = std::static_pointer_cast<OpType>(op); \

  39.         (void)p->set_input_##name(*(handle.op), handle.out); \

  40.     }, \

  41.     [](const OperatorPtr op, const GeTensorDesc desc) { \

  42.         auto p = std::static_pointer_cast<OpType>(op); \

  43.         (void)p->update_input_desc_##name(desc); \

  44.     }                 \

  45.   }

  46. 

  47. #define DYN_INPUT_MAP(T) \

  48.   template <>            \

  49.   const std::unordered_map<int, DynInputDesc> OpAdapter<T>::dyn_input_map_

  50. #define DYN_INPUT_DESC(name) \

  51.   {                          \

  52. #name, \

  53.     [](const OperatorPtr op, unsigned int num) { \

  54.         auto p = std::static_pointer_cast<OpType>(op); \

  55.         (void)p->create_dynamic_input_##name(num); \

  56.     }, \

  57.     [](const OperatorPtr op, unsigned int index, const OperatorPtr input) { \

  58.         auto p = std::static_pointer_cast<OpType>(op); \

  59.         (void)p->set_dynamic_input_##name(index, *input); \

  60.     }, \

  61.     [](const OperatorPtr op, unsigned int index, const OutHandler& handle) { \

  62.         auto p = std::static_pointer_cast<OpType>(op); \

  63.         (void)p->set_dynamic_input_##name(index, *(handle.op), handle.out); \

  64.     }                     \

  65.   }

  66. 

  67. #define ATTR_MAP(T) \

  68.   template <>       \

  69.   const std::unordered_map<std::string, AttrDesc> OpAdapter<T>::attr_map_

  70. #define EMPTY_ATTR_MAP std::unordered_map<std::string, AttrDesc>()

  71. #define ATTR_DESC(name, ...) \

  72.   {                          \

  73. #name, \

  74.     [](const OperatorPtr op, const ValuePtr& value) { \

  75.         auto p = std::static_pointer_cast<OpType>(op); \

  76.         (void)p->set_attr_##name(ConvertAny(value, __VA_ARGS__)); \

  77.     }                     \

  78.   }

  79. 

  80. #define INPUT_ATTR_MAP(T) \

  81.   template <>             \

  82.   const std::unordered_map<unsigned int, AttrDesc> OpAdapter<T>::input_attr_map_

  83. 

  84. #define OUTPUT_MAP(T) \

  85.   template <>         \

  86.   const std::unordered_map<int, OutputDesc> OpAdapter<T>::output_map_

  87. #define OUTPUT_DESC(name) \

  88.   {                       \

  89. #name, \

  90.     [](const OperatorPtr op, const GeTensorDesc desc) { \

  91.         auto p = std::static_pointer_cast<OpType>(op); \

  92.         (void)p->update_output_desc_##name(desc); \

  93.     }                  \

  94.   }

  95. 

  96. #define DYN_OUTPUT_MAP(T) \

  97.   template <>             \

  98.   const std::unordered_map<int, DynOutputDesc> OpAdapter<T>::dyn_output_map_

  99. 

  100. #define DYN_OUTPUT_DESC(name) \

  101.   {                           \

  102. #name, \

  103.     [](const OperatorPtr op, unsigned int num) { \

  104.         auto p = std::static_pointer_cast<OpType>(op); \

  105.         (void)p->create_dynamic_output_##name(num); \

  106.     }                      \

  107.   }

  108. 

  109. template <>

  110. std::unordered_map<std::string, std::unordered_map<int, std::string>> OpAdapter<ge::Operator>::cus_input_map_{};

  111. template <>

  112. std::unordered_map<std::string, std::unordered_map<int, std::string>> OpAdapter<ge::Operator>::cus_output_map_{};

  113. 

  114. // --------------specialization for each operator----------

  115. // const

  116. INPUT_MAP(Const) = EMPTY_INPUT_MAP;

  117. ATTR_MAP(Const) = {{"value", ATTR_DESC(value, AnyTraits<AnyValue>())}};

  118. OUTPUT_MAP(Const) = {{0, OUTPUT_DESC(y)}};

  119. 

  120. // Assign

  121. INPUT_MAP(Assign) = {{1, INPUT_DESC(ref)}, {2, INPUT_DESC(value)}};

  122. ATTR_MAP(Assign) = EMPTY_ATTR_MAP;

  123. OUTPUT_MAP(Assign) = {{0, OUTPUT_DESC(ref)}};

  124. 

  125. // Constant

  126. INPUT_MAP(Constant) = EMPTY_INPUT_MAP;

  127. ATTR_MAP(Constant) = {{"value", ATTR_DESC(value, AnyTraits<AnyValue>())}};

  128. OUTPUT_MAP(Constant) = {{0, OUTPUT_DESC(y)}};

  129. 

  130. // ApplyMomentum

  131. INPUT_MAP(ApplyMomentum) = {

  132.   {1, INPUT_DESC(var)}, {2, INPUT_DESC(accum)}, {3, INPUT_DESC(lr)}, {4, INPUT_DESC(grad)}, {5, INPUT_DESC(momentum)}};

  133. ATTR_MAP(ApplyMomentum) = {{"use_nesterov", ATTR_DESC(use_nesterov, AnyTraits<bool>())},

  134.                            {"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())}};

  135. OUTPUT_MAP(ApplyMomentum) = {{0, OUTPUT_DESC(var)}};

  136. 

  137. // ScalarSummary

  138. INPUT_MAP(Summary) = {{2, INPUT_DESC(x)}};

  139. ATTR_MAP(Summary) = EMPTY_ATTR_MAP;

  140. 

  141. // data

  142. INPUT_MAP(Data) = EMPTY_INPUT_MAP;

  143. ATTR_MAP(Data) = EMPTY_ATTR_MAP;

  144. 

  145. // resnet ops in ge

  146. // BatchNorm

  147. INPUT_MAP(BatchNorm) = {{1, INPUT_DESC(x)},

  148.                         {2, INPUT_DESC(scale)},

  149.                         {3, INPUT_DESC(offset)},

  150.                         {4, INPUT_DESC(mean)},

  151.                         {5, INPUT_DESC(variance)}};

  152. ATTR_MAP(BatchNorm) = {{"data_format", ATTR_DESC(data_format, AnyTraits<std::string>())},

  153.                        {"epsilon", ATTR_DESC(epsilon, AnyTraits<float>())},

  154.                        {"is_training", ATTR_DESC(is_training, AnyTraits<bool>())}};

  155. OUTPUT_MAP(BatchNorm) = {{0, OUTPUT_DESC(y)},

  156.                          {1, OUTPUT_DESC(batch_mean)},

  157.                          {2, OUTPUT_DESC(batch_variance)},

  158.                          {3, OUTPUT_DESC(reserve_space_1)},

  159.                          {4, OUTPUT_DESC(reserve_space_2)},

  160.                          {5, OUTPUT_DESC(reserve_space_3)}};

  161. 

  162. // BatchNormGrad

  163. INPUT_MAP(BatchNormGrad) = {{1, INPUT_DESC(y_backprop)},      {2, INPUT_DESC(x)},

  164.                             {3, INPUT_DESC(scale)},           {4, INPUT_DESC(reserve_space_1)},

  165.                             {5, INPUT_DESC(reserve_space_2)}, {6, INPUT_DESC(reserve_space_3)}};

  166. ATTR_MAP(BatchNormGrad) = {{"data_format", ATTR_DESC(data_format, AnyTraits<std::string>())},

  167.                            {"epsilon", ATTR_DESC(epsilon, AnyTraits<float>())},

  168.                            {"is_training", ATTR_DESC(is_training, AnyTraits<bool>())}};

  169. OUTPUT_MAP(BatchNormGrad) = {{0, OUTPUT_DESC(x_backprop)},

  170.                              {1, OUTPUT_DESC(scale_backprop)},

  171.                              {2, OUTPUT_DESC(offset_backprop)},

  172.                              {3, OUTPUT_DESC(reserve_space_4)},

  173.                              {4, OUTPUT_DESC(reserve_space_5)}};

  174. 

  175. // Relu

  176. INPUT_MAP(Relu) = {{1, INPUT_DESC(x)}};

  177. ATTR_MAP(Relu) = EMPTY_ATTR_MAP;

  178. OUTPUT_MAP(Relu) = {{0, OUTPUT_DESC(y)}};

  179. 

  180. // Elu

  181. INPUT_MAP(Elu) = {{1, INPUT_DESC(x)}};

  182. ATTR_MAP(Elu) = {{"alpha", ATTR_DESC(alpha, AnyTraits<float>())}};

  183. OUTPUT_MAP(Elu) = {{0, OUTPUT_DESC(y)}};

  184. 

  185. // EluGrad

  186. INPUT_MAP(EluGrad) = {{1, INPUT_DESC(grads)}, {2, INPUT_DESC(activations)}};

  187. ATTR_MAP(EluGrad) = EMPTY_ATTR_MAP;

  188. OUTPUT_MAP(EluGrad) = {{0, OUTPUT_DESC(y)}};

  189. 

  190. // PRelu

  191. INPUT_MAP(PRelu) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(weight)}};

  192. ATTR_MAP(PRelu) = EMPTY_ATTR_MAP;

  193. OUTPUT_MAP(PRelu) = {{0, OUTPUT_DESC(y)}};

  194. 

  195. // PReluGrad

  196. INPUT_MAP(PReluGrad) = {

  197.   {1, INPUT_DESC(input_gradients)}, {2, INPUT_DESC(input_features)}, {3, INPUT_DESC(input_weights)}};

  198. ATTR_MAP(PReluGrad) = EMPTY_ATTR_MAP;

  199. OUTPUT_MAP(PReluGrad) = {{0, OUTPUT_DESC(output_backprops_dx)}, {1, OUTPUT_DESC(output_backprops_da)}};

  200. 

  201. // Sigmoid

  202. INPUT_MAP(Sigmoid) = {{1, INPUT_DESC(x)}};

  203. ATTR_MAP(Sigmoid) = EMPTY_ATTR_MAP;

  204. OUTPUT_MAP(Sigmoid) = {{0, OUTPUT_DESC(y)}};

  205. 

  206. // SigmoidGrad

  207. INPUT_MAP(SigmoidGrad) = {{1, INPUT_DESC(y)}, {2, INPUT_DESC(dy)}};

  208. ATTR_MAP(SigmoidGrad) = EMPTY_ATTR_MAP;

  209. OUTPUT_MAP(SigmoidGrad) = {{0, OUTPUT_DESC(z)}};

  210. 

  211. // L2NormalizeGrad

  212. INPUT_MAP(L2NormalizeGrad) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(y)}, {3, INPUT_DESC(dy)}};

  213. ATTR_MAP(L2NormalizeGrad) = {

  214.   {"axis", ATTR_DESC(dim, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},

  215.   {"epsilon", ATTR_DESC(eps, AnyTraits<float>())}};

  216. OUTPUT_MAP(L2NormalizeGrad) = {{0, OUTPUT_DESC(dx)}};

  217. 

  218. // LarsV2Update

  219. INPUT_MAP(LarsV2Update) = {{1, INPUT_DESC(w)},

  220.                            {2, INPUT_DESC(g)},

  221.                            {3, INPUT_DESC(w_square_sum)},

  222.                            {4, INPUT_DESC(g_square_sum)},

  223.                            {5, INPUT_DESC(weight_decay)},

  224.                            {6, INPUT_DESC(learning_rate)}};

  225. ATTR_MAP(LarsV2Update) = {{"epsilon", ATTR_DESC(epsilon, AnyTraits<float>())},

  226.                           {"hyperpara", ATTR_DESC(hyperpara, AnyTraits<float>())},

  227.                           {"use_clip", ATTR_DESC(use_clip, AnyTraits<bool>())}};

  228. OUTPUT_MAP(LarsV2Update) = {{0, OUTPUT_DESC(g_new)}};

  229. 

  230. // L2Normalize

  231. INPUT_MAP(L2Normalize) = {{1, INPUT_DESC(x)}};

  232. ATTR_MAP(L2Normalize) = {

  233.   {"axis", ATTR_DESC(axis, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},

  234.   {"epsilon", ATTR_DESC(eps, AnyTraits<float>())}};

  235. OUTPUT_MAP(L2Normalize) = {{0, OUTPUT_DESC(y)}};

  236. 

  237. // CumsumD

  238. INPUT_MAP(CumsumD) = {{1, INPUT_DESC(x)}};

  239. INPUT_ATTR_MAP(CumsumD) = {{2, ATTR_DESC(axis, AnyTraits<int64_t>())}};

  240. ATTR_MAP(CumsumD) = {{"exclusive", ATTR_DESC(exclusive, AnyTraits<bool>())},

  241.                      {"reverse", ATTR_DESC(reverse, AnyTraits<bool>())}};

  242. OUTPUT_MAP(CumsumD) = {{0, OUTPUT_DESC(y)}};

  243. 

  244. // softmax

  245. INPUT_MAP(Softmax) = {{1, INPUT_DESC(x)}};

  246. ATTR_MAP(Softmax) = {

  247.   {"axis", ATTR_DESC(axis, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},

  248. };

  249. OUTPUT_MAP(Softmax) = {{0, OUTPUT_DESC(y)}};

  250. 

  251. // SoftmaxGrad

  252. INPUT_MAP(SoftmaxGrad) = {{1, INPUT_DESC(softmax)}, {2, INPUT_DESC(grad_softmax)}};

  253. OUTPUT_MAP(SoftmaxGrad) = {{0, OUTPUT_DESC(grad_x)}};

  254. ATTR_MAP(SoftmaxGrad) = EMPTY_ATTR_MAP;

  255. 

  256. // Flatten

  257. INPUT_MAP(Flatten) = {{1, INPUT_DESC(x)}};

  258. ATTR_MAP(Flatten) = EMPTY_ATTR_MAP;

  259. OUTPUT_MAP(Flatten) = {{0, OUTPUT_DESC(y)}};

  260. 

  261. // add

  262. INPUT_MAP(Add) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};

  263. ATTR_MAP(Add) = EMPTY_ATTR_MAP;

  264. OUTPUT_MAP(Add) = {{0, OUTPUT_DESC(y)}};

  265. 

  266. // GatherV2

  267. INPUT_MAP(GatherV2) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(indices)}, {3, INPUT_DESC(axis)}};

  268. ATTR_MAP(GatherV2) = EMPTY_ATTR_MAP;

  269. OUTPUT_MAP(GatherV2) = {{0, OUTPUT_DESC(y)}};

  270. 

  271. // ReduceSum

  272. INPUT_MAP(ReduceSum) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(axis)}};

  273. ATTR_MAP(ReduceSum) = {{"keep_dims", ATTR_DESC(keep_dims, AnyTraits<bool>())}};

  274. OUTPUT_MAP(ReduceSum) = {{0, OUTPUT_DESC(y)}};

  275. 

  276. // ReduceSumD

  277. INPUT_MAP(ReduceSumD) = {{1, INPUT_DESC(x)}};

  278. INPUT_ATTR_MAP(ReduceSumD) = {

  279.   {2, ATTR_DESC(axis, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};

  280. ATTR_MAP(ReduceSumD) = {{"keep_dims", ATTR_DESC(keep_dims, AnyTraits<bool>())}};

  281. OUTPUT_MAP(ReduceSumD) = {{0, OUTPUT_DESC(y)}};

  282. 

  283. // ReduceProdD

  284. INPUT_MAP(ReduceProdD) = {{1, INPUT_DESC(x)}};

  285. INPUT_ATTR_MAP(ReduceProdD) = {

  286.   {2, ATTR_DESC(axis, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};

  287. ATTR_MAP(ReduceProdD) = {{"keep_dims", ATTR_DESC(keep_dims, AnyTraits<bool>())}};

  288. OUTPUT_MAP(ReduceProdD) = {{0, OUTPUT_DESC(y)}};

  289. 

  290. // CumprodD

  291. INPUT_MAP(CumprodD) = {{1, INPUT_DESC(x)}};

  292. INPUT_ATTR_MAP(CumprodD) = {{2, ATTR_DESC(axis, AnyTraits<int64_t>())}};

  293. ATTR_MAP(CumprodD) = {{"exclusive", ATTR_DESC(exclusive, AnyTraits<bool>())},

  294.                       {"reverse", ATTR_DESC(reverse, AnyTraits<bool>())}};

  295. OUTPUT_MAP(CumprodD) = {{0, OUTPUT_DESC(y)}};

  296. 

  297. // SoftmaxCrossEntropyWithLogits/

  298. INPUT_MAP(SoftmaxCrossEntropyWithLogits) = {{1, INPUT_DESC(features)}, {2, INPUT_DESC(labels)}};

  299. ATTR_MAP(SoftmaxCrossEntropyWithLogits) = EMPTY_ATTR_MAP;

  300. OUTPUT_MAP(SoftmaxCrossEntropyWithLogits) = {{0, OUTPUT_DESC(loss)}, {1, OUTPUT_DESC(backprop)}};

  301. 

  302. // MeanGrad

  303. INPUT_MAP(MeanGrad) = {{1, INPUT_DESC(x)}};

  304. INPUT_ATTR_MAP(MeanGrad) = {{2, ATTR_DESC(mean_grad_output_shape_value, kOpFormat_NHWC,

  305.                                           AnyTraits<std::vector<int64_t>>(), AnyTraits<int64_t>())}};

  306. ATTR_MAP(MeanGrad) = {{"mode", ATTR_DESC(mode, AnyTraits<int64_t>())}};

  307. 

  308. INPUT_MAP(SliceD) = {{1, INPUT_DESC(x)}};

  309. INPUT_ATTR_MAP(SliceD) = {{2, ATTR_DESC(begin, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},

  310.                           {3, ATTR_DESC(size, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())}};

  311. ATTR_MAP(SliceD) = EMPTY_ATTR_MAP;

  312. OUTPUT_MAP(SliceD) = {{0, OUTPUT_DESC(y)}};

  313. 

  314. // MaxPool

  315. INPUT_MAP(MaxPool) = {{1, INPUT_DESC(x)}};

  316. ATTR_MAP(MaxPool) = {{"ksize", ATTR_DESC(ksize, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},

  317.                      {"strides", ATTR_DESC(strides, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},

  318.                      {"padding", ATTR_DESC(padding, AnyTraits<std::string>())},

  319.                      {"data_format", ATTR_DESC(data_format, AnyTraits<std::string>())}};

  320. OUTPUT_MAP(MaxPool) = {{0, OUTPUT_DESC(y)}};

  321. 

  322. // AvgPool

  323. INPUT_MAP(AvgPool) = {{1, INPUT_DESC(x)}};

  324. ATTR_MAP(AvgPool) = {{"ksize", ATTR_DESC(ksize, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},

  325.                      {"strides", ATTR_DESC(strides, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},

  326.                      {"padding", ATTR_DESC(padding, AnyTraits<std::string>())},

  327.                      {"data_format", ATTR_DESC(data_format, AnyTraits<std::string>())}};

  328. OUTPUT_MAP(AvgPool) = {{0, OUTPUT_DESC(y)}};

  329. 

  330. // GreaterEqual

  331. INPUT_MAP(GreaterEqual) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};

  332. ATTR_MAP(GreaterEqual) = EMPTY_ATTR_MAP;

  333. OUTPUT_MAP(GreaterEqual) = {{0, OUTPUT_DESC(y)}};

  334. 

  335. // AssignAdd

  336. INPUT_MAP(AssignAdd) = {{1, INPUT_DESC(ref)}, {2, INPUT_DESC(value)}};

  337. ATTR_MAP(AssignAdd) = EMPTY_ATTR_MAP;

  338. OUTPUT_MAP(AssignAdd) = {{0, OUTPUT_DESC(ref)}};

  339. 

  340. // AssignSub

  341. INPUT_MAP(AssignSub) = {{1, INPUT_DESC(var)}, {2, INPUT_DESC(value)}};

  342. ATTR_MAP(AssignSub) = EMPTY_ATTR_MAP;

  343. OUTPUT_MAP(AssignSub) = {{0, OUTPUT_DESC(var)}};

  344. 

  345. // Cos

  346. INPUT_MAP(Cos) = {{1, INPUT_DESC(x)}};

  347. ATTR_MAP(Cos) = EMPTY_ATTR_MAP;

  348. OUTPUT_MAP(Cos) = {{0, OUTPUT_DESC(y)}};

  349. 

  350. // Acos

  351. INPUT_MAP(Acos) = {{1, INPUT_DESC(x)}};

  352. ATTR_MAP(Acos) = EMPTY_ATTR_MAP;

  353. OUTPUT_MAP(Acos) = {{0, OUTPUT_DESC(y)}};

  354. 

  355. // AcosGrad

  356. INPUT_MAP(AcosGrad) = {{1, INPUT_DESC(y)}, {2, INPUT_DESC(dy)}};

  357. ATTR_MAP(AcosGrad) = EMPTY_ATTR_MAP;

  358. OUTPUT_MAP(AcosGrad) = {{0, OUTPUT_DESC(z)}};

  359. 

  360. // Acosh

  361. INPUT_MAP(Acosh) = {{1, INPUT_DESC(x)}};

  362. ATTR_MAP(Acosh) = EMPTY_ATTR_MAP;

  363. OUTPUT_MAP(Acosh) = {{0, OUTPUT_DESC(y)}};

  364. 

  365. // Floor

  366. INPUT_MAP(Floor) = {{1, INPUT_DESC(x)}};

  367. ATTR_MAP(Floor) = EMPTY_ATTR_MAP;

  368. OUTPUT_MAP(Floor) = {{0, OUTPUT_DESC(y)}};

  369. 

  370. // FloorDiv

  371. INPUT_MAP(FloorDiv) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};

  372. ATTR_MAP(FloorDiv) = EMPTY_ATTR_MAP;

  373. OUTPUT_MAP(FloorDiv) = {{0, OUTPUT_DESC(y)}};

  374. 

  375. // FloorMod

  376. INPUT_MAP(FloorMod) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};

  377. ATTR_MAP(FloorMod) = EMPTY_ATTR_MAP;

  378. OUTPUT_MAP(FloorMod) = {{0, OUTPUT_DESC(y)}};

  379. 

  380. // Sin

  381. INPUT_MAP(Sin) = {{1, INPUT_DESC(x)}};

  382. ATTR_MAP(Sin) = EMPTY_ATTR_MAP;

  383. OUTPUT_MAP(Sin) = {{0, OUTPUT_DESC(y)}};

  384. 

  385. // Exp

  386. INPUT_MAP(Exp) = {{1, INPUT_DESC(x)}};

  387. ATTR_MAP(Exp) = EMPTY_ATTR_MAP;

  388. OUTPUT_MAP(Exp) = {{0, OUTPUT_DESC(y)}};

  389. 

  390. // BoundingBoxEncode

  391. INPUT_MAP(BoundingBoxEncode) = {

  392.   {1, INPUT_DESC(anchor_box)},

  393.   {2, INPUT_DESC(ground_truth_box)},

  394. };

  395. ATTR_MAP(BoundingBoxEncode) = {

  396.   {"means", ATTR_DESC(means, AnyTraits<std::vector<float>>(), AnyTraits<float>())},

  397.   {"stds", ATTR_DESC(stds, AnyTraits<std::vector<float>>(), AnyTraits<float>())},

  398. };

  399. OUTPUT_MAP(BoundingBoxEncode) = {{0, OUTPUT_DESC(delats)}};

  400. 

  401. // BoundingBoxDecode

  402. INPUT_MAP(BoundingBoxDecode) = {

  403.   {1, INPUT_DESC(rois)},

  404.   {2, INPUT_DESC(deltas)},

  405. };

  406. ATTR_MAP(BoundingBoxDecode) = {

  407.   {"means", ATTR_DESC(means, AnyTraits<std::vector<float>>(), AnyTraits<float>())},

  408.   {"stds", ATTR_DESC(stds, AnyTraits<std::vector<float>>(), AnyTraits<float>())},

  409.   {"max_shape", ATTR_DESC(max_shape, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},

  410.   {"wh_ratio_clip", ATTR_DESC(wh_ratio_clip, AnyTraits<float>())},

  411. };

  412. OUTPUT_MAP(BoundingBoxDecode) = {{0, OUTPUT_DESC(bboxes)}};

  413. 

  414. #ifdef VALID_CODE

  415. 

  416. // Less

  417. INPUT_MAP(Less) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(y)}};

  418. ATTR_MAP(Less) = EMPTY_ATTR_MAP;

  419. OUTPUT_MAP(Less) = {{0, OUTPUT_DESC(z)}};

  420. 

  421. // Cast

  422. INPUT_MAP(Cast) = {{1, INPUT_DESC(x)}};

  423. INPUT_ATTR_MAP(Cast) = {{2, ATTR_DESC(dst_type, AnyTraits<GEType>())}};

  424. ATTR_MAP(Cast) = {{"Truncate", ATTR_DESC(truncate, AnyTraits<bool>())}};

  425. OUTPUT_MAP(Cast) = {{0, OUTPUT_DESC(y)}};

  426. 

  427. // Minimum

  428. INPUT_MAP(Minimum) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(y)}};

  429. ATTR_MAP(Minimum) = {{"alpha", ATTR_DESC(alpha, AnyTraits<float>())}, {"beta", ATTR_DESC(beta, AnyTraits<float>())}};

  430. OUTPUT_MAP(Minimum) = {{0, OUTPUT_DESC(z)}};

  431. 

  432. // Sub

  433. INPUT_MAP(Sub) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};

  434. ATTR_MAP(Sub) = {{"alpha", ATTR_DESC(alpha, AnyTraits<float>())}, {"beta", ATTR_DESC(beta, AnyTraits<float>())}};

  435. 

  436. #endif

  437. 

  438. // TopKV2

  439. INPUT_MAP(TopKV2) = {

  440.   {1, INPUT_DESC(input)},

  441.   {2, INPUT_DESC(k)},

  442. };

  443. 

  444. ATTR_MAP(TopKV2) = {{"T", ATTR_DESC(T, AnyTraits<GEType>())}, {"sorted", ATTR_DESC(sorted, AnyTraits<bool>())}};

  445. 

  446. OUTPUT_MAP(TopKV2) = {

  447.   {0, OUTPUT_DESC(values)},

  448.   {1, OUTPUT_DESC(indices)},

  449. };

  450. 

  451. // Multiply

  452. INPUT_MAP(Multiply) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(y)}};

  453. ATTR_MAP(Multiply) = EMPTY_ATTR_MAP;

  454. OUTPUT_MAP(Multiply) = {{0, OUTPUT_DESC(z)}};

  455. 

  456. // TileD

  457. INPUT_MAP(TileD) = {{1, INPUT_DESC(x)}};

  458. INPUT_ATTR_MAP(TileD) = {{2, ATTR_DESC(multiples, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())}};

  459. ATTR_MAP(TileD) = EMPTY_ATTR_MAP;

  460. OUTPUT_MAP(TileD) = {{0, OUTPUT_DESC(y)}};

  461. 

  462. // OneHot

  463. INPUT_MAP(OneHot) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(depth)}, {3, INPUT_DESC(on_value)}, {4, INPUT_DESC(off_value)}};

  464. ATTR_MAP(OneHot) = {{"axis", ATTR_DESC(axis, AnyTraits<int64_t>())}};

  465. OUTPUT_MAP(OneHot) = {{0, OUTPUT_DESC(y)}};

  466. 

  467. // GatherV2D

  468. INPUT_MAP(GatherV2D) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(indices)}};

  469. INPUT_ATTR_MAP(GatherV2D) = {{3, ATTR_DESC(axis, AnyTraits<int64_t>())}};

  470. ATTR_MAP(GatherV2D) = EMPTY_ATTR_MAP;

  471. OUTPUT_MAP(GatherV2D) = {{0, OUTPUT_DESC(y)}};

  472. 

  473. // Reshape

  474. INPUT_MAP(Reshape) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(shape)}};

  475. ATTR_MAP(Reshape) = EMPTY_ATTR_MAP;

  476. OUTPUT_MAP(Reshape) = {{0, OUTPUT_DESC(y)}};

  477. 

  478. // BiasAdd

  479. INPUT_MAP(BiasAdd) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(bias)}};

  480. ATTR_MAP(BiasAdd) = {{"data_format", ATTR_DESC(data_format, AnyTraits<std::string>())}};

  481. OUTPUT_MAP(BiasAdd) = {{0, OUTPUT_DESC(y)}};

  482. 

  483. // Iou

  484. INPUT_MAP(Iou) = {{1, INPUT_DESC(bboxes)}, {2, INPUT_DESC(gtboxes)}};

  485. ATTR_MAP(Iou) = {{"mode", ATTR_DESC(mode, AnyTraits<std::string>())}};

  486. OUTPUT_MAP(Iou) = {{0, OUTPUT_DESC(overlap)}};

  487. 

  488. // ResizeNearestNeighborD

  489. INPUT_MAP(ResizeNearestNeighborD) = {{1, INPUT_DESC(images)}};

  490. ATTR_MAP(ResizeNearestNeighborD) = {

  491.   {"size", ATTR_DESC(size, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},

  492.   {"align_corners", ATTR_DESC(align_corners, AnyTraits<bool>())}};

  493. OUTPUT_MAP(ResizeNearestNeighborD) = {{0, OUTPUT_DESC(y)}};

  494. 

  495. // ResizeNearestNeighborGrad

  496. INPUT_MAP(ResizeNearestNeighborGrad) = {{1, INPUT_DESC(grads)}, {2, INPUT_DESC(size)}};

  497. ATTR_MAP(ResizeNearestNeighborGrad) = {{"align_corners", ATTR_DESC(align_corners, AnyTraits<bool>())}};

  498. OUTPUT_MAP(ResizeNearestNeighborGrad) = {{0, OUTPUT_DESC(y)}};

  499. 

  500. // ApplyAdam

  501. INPUT_MAP(ApplyAdam) = {{1, INPUT_DESC(var)},         {2, INPUT_DESC(m)},           {3, INPUT_DESC(v)},

  502.                         {4, INPUT_DESC(beta1_power)}, {5, INPUT_DESC(beta2_power)}, {6, INPUT_DESC(lr)},

  503.                         {7, INPUT_DESC(beta1)},       {8, INPUT_DESC(beta2)},       {9, INPUT_DESC(epsilon)},

  504.                         {10, INPUT_DESC(grad)}};

  505. ATTR_MAP(ApplyAdam) = {{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())},

  506.                        {"use_nesterov", ATTR_DESC(use_nesterov, AnyTraits<bool>())}};

  507. #ifdef ENABLE_GE

  508. OUTPUT_MAP(ApplyAdam) = {{0, OUTPUT_DESC(var)}, {1, OUTPUT_DESC(m)}, {2, OUTPUT_DESC(v)}};

  509. #else

  510. OUTPUT_MAP(ApplyAdam) = {{0, OUTPUT_DESC(var)}};

  511. #endif

  512. 

  513. // Relu6

  514. INPUT_MAP(Relu6) = {{1, INPUT_DESC(features)}};

  515. ATTR_MAP(Relu6) = EMPTY_ATTR_MAP;

  516. OUTPUT_MAP(Relu6) = {{0, OUTPUT_DESC(activations)}};

  517. 

  518. // Relu6Grad

  519. INPUT_MAP(Relu6Grad) = {{1, INPUT_DESC(gradients)}, {2, INPUT_DESC(features)}};

  520. ATTR_MAP(Relu6Grad) = EMPTY_ATTR_MAP;

  521. OUTPUT_MAP(Relu6Grad) = {{0, OUTPUT_DESC(backprops)}};

  522. 

  523. // ResizeBilinearGrad

  524. INPUT_MAP(ResizeBilinearGrad) = {{1, INPUT_DESC(grads)}, {2, INPUT_DESC(original_image)}};

  525. ATTR_MAP(ResizeBilinearGrad) = {{"align_corners", ATTR_DESC(align_corners, AnyTraits<bool>())}};

  526. OUTPUT_MAP(ResizeBilinearGrad) = {{0, OUTPUT_DESC(y)}};

  527. 

  528. // ResizeBilinear

  529. INPUT_MAP(ResizeBilinearD) = {{1, INPUT_DESC(images)}};

  530. ATTR_MAP(ResizeBilinearD) = {

  531.   {"size", ATTR_DESC(size, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},

  532.   {"align_corners", ATTR_DESC(align_corners, AnyTraits<bool>())}};

  533. OUTPUT_MAP(ResizeBilinearD) = {{0, OUTPUT_DESC(y)}};

  534. 

  535. // ZerosLike

  536. INPUT_MAP(ZerosLike) = {{1, INPUT_DESC(x)}};

  537. ATTR_MAP(ZerosLike) = EMPTY_ATTR_MAP;

  538. OUTPUT_MAP(ZerosLike) = {{0, OUTPUT_DESC(y)}};

  539. 

  540. // OnesLike

  541. INPUT_MAP(OnesLike) = {{1, INPUT_DESC(x)}};

  542. ATTR_MAP(OnesLike) = EMPTY_ATTR_MAP;

  543. OUTPUT_MAP(OnesLike) = {{0, OUTPUT_DESC(y)}};

  544. 

  545. // NMSWithMask

  546. INPUT_MAP(NMSWithMask) = {{1, INPUT_DESC(box_scores)}};

  547. ATTR_MAP(NMSWithMask) = {{"iou_threshold", ATTR_DESC(iou_threshold, AnyTraits<float>())}};

  548. OUTPUT_MAP(NMSWithMask) = {

  549.   {0, OUTPUT_DESC(selected_boxes)}, {1, OUTPUT_DESC(selected_idx)}, {2, OUTPUT_DESC(selected_mask)}};

  550. 

  551. // Unpack

  552. INPUT_MAP(Unpack) = {{1, INPUT_DESC(value)}};

  553. ATTR_MAP(Unpack) = {{"axis", ATTR_DESC(axis, AnyTraits<int>())}, {"num", ATTR_DESC(num, AnyTraits<int>())}};

  554. DYN_OUTPUT_MAP(Unpack) = {{0, DYN_OUTPUT_DESC(output)}};

  555. 

  556. // ScatterNdUpdate

  557. INPUT_MAP(ScatterNdUpdate) = {{1, INPUT_DESC(var)}, {2, INPUT_DESC(indices)}, {3, INPUT_DESC(updates)}};

  558. ATTR_MAP(ScatterNdUpdate) = {{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())}};

  559. OUTPUT_MAP(ScatterNdUpdate) = {{0, OUTPUT_DESC(var)}};

  560. 

  561. // CheckValid

  562. INPUT_MAP(CheckValid) = {{1, INPUT_DESC(bbox_tensor)}, {2, INPUT_DESC(img_metas)}};

  563. ATTR_MAP(CheckValid) = EMPTY_ATTR_MAP;

  564. OUTPUT_MAP(CheckValid) = {{0, OUTPUT_DESC(valid_tensor)}};

  565. 

  566. // SmoothL1Loss

  567. INPUT_MAP(SmoothL1Loss) = {{1, INPUT_DESC(predict)}, {2, INPUT_DESC(label)}};

  568. ATTR_MAP(SmoothL1Loss) = {{"sigma", ATTR_DESC(sigma, AnyTraits<float>())}};

  569. OUTPUT_MAP(SmoothL1Loss) = {{0, OUTPUT_DESC(loss)}};

  570. 

  571. // SmoothL1LossGrad

  572. INPUT_MAP(SmoothL1LossGrad) = {{1, INPUT_DESC(predict)}, {2, INPUT_DESC(label)}, {3, INPUT_DESC(dout)}};

  573. ATTR_MAP(SmoothL1LossGrad) = {{"sigma", ATTR_DESC(sigma, AnyTraits<float>())}};

  574. OUTPUT_MAP(SmoothL1LossGrad) = {{0, OUTPUT_DESC(gradient)}};

  575. 

  576. // SigmoidCrossEntropyWithLogits

  577. INPUT_MAP(SigmoidCrossEntropyWithLogits) = {{1, INPUT_DESC(predict)}, {2, INPUT_DESC(target)}};

  578. ATTR_MAP(SigmoidCrossEntropyWithLogits) = EMPTY_ATTR_MAP;

  579. OUTPUT_MAP(SigmoidCrossEntropyWithLogits) = {{0, OUTPUT_DESC(loss)}};

  580. 

  581. // SigmoidCrossEntropyWithLogitsGrad

  582. INPUT_MAP(SigmoidCrossEntropyWithLogitsGrad) = {

  583.   {1, INPUT_DESC(predict)}, {2, INPUT_DESC(target)}, {3, INPUT_DESC(dout)}};

  584. ATTR_MAP(SigmoidCrossEntropyWithLogitsGrad) = EMPTY_ATTR_MAP;

  585. OUTPUT_MAP(SigmoidCrossEntropyWithLogitsGrad) = {{0, OUTPUT_DESC(gradient)}};

  586. 

  587. // ScatterNd

  588. INPUT_MAP(ScatterNdD) = {{1, INPUT_DESC(indices)}, {2, INPUT_DESC(updates)}};

  589. INPUT_ATTR_MAP(ScatterNdD) = {

  590.   {3, ATTR_DESC(shape, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};

  591. ATTR_MAP(ScatterNdD) = EMPTY_ATTR_MAP;

  592. OUTPUT_MAP(ScatterNdD) = {{0, OUTPUT_DESC(y)}};

  593. 

  594. // PadD

  595. INPUT_MAP(PadD) = {{1, INPUT_DESC(x)}};

  596. ATTR_MAP(PadD) = {{"paddings", ATTR_DESC(paddings, AnyTraits<std::vector<std::vector<int64_t>>>())}};

  597. OUTPUT_MAP(PadD) = {{0, OUTPUT_DESC(y)}};

  598. 

  599. // MirrorPad

  600. INPUT_MAP(MirrorPad) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(paddings)}};

  601. ATTR_MAP(MirrorPad) = {{"mode", ATTR_DESC(mode, AnyTraits<std::string>())}};

  602. OUTPUT_MAP(MirrorPad) = {{0, OUTPUT_DESC(y)}};

  603. 

  604. // MirrorPadGrad

  605. INPUT_MAP(MirrorPadGrad) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(paddings)}};

  606. ATTR_MAP(MirrorPadGrad) = {{"mode", ATTR_DESC(mode, AnyTraits<std::string>())}};

  607. OUTPUT_MAP(MirrorPadGrad) = {{0, OUTPUT_DESC(y)}};

  608. 

  609. // GatherNd

  610. INPUT_MAP(GatherNd) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};

  611. ATTR_MAP(GatherNd) = EMPTY_ATTR_MAP;

  612. OUTPUT_MAP(GatherNd) = {{0, OUTPUT_DESC(y)}};

  613. 

  614. // ROIAlign

  615. INPUT_MAP(ROIAlign) = {{1, INPUT_DESC(features)}, {2, INPUT_DESC(rois)}};

  616. OUTPUT_MAP(ROIAlign) = {{0, OUTPUT_DESC(output)}};

  617. ATTR_MAP(ROIAlign) = {{"pooled_height", ATTR_DESC(pooled_height, AnyTraits<int>())},

  618.                       {"pooled_width", ATTR_DESC(pooled_width, AnyTraits<int>())},

  619.                       {"spatial_scale", ATTR_DESC(spatial_scale, AnyTraits<float>())},

  620.                       {"sample_num", ATTR_DESC(sample_num, AnyTraits<int>())}};

  621. 

  622. // ROIAlignGrad

  623. INPUT_MAP(ROIAlignGrad) = {{1, INPUT_DESC(ydiff)}, {2, INPUT_DESC(rois)}};

  624. OUTPUT_MAP(ROIAlignGrad) = {{0, OUTPUT_DESC(xdiff)}};

  625. ATTR_MAP(ROIAlignGrad) = {

  626.   {"xdiff_shape", ATTR_DESC(xdiff_shape, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},

  627.   {"pooled_height", ATTR_DESC(pooled_height, AnyTraits<int>())},

  628.   {"pooled_width", ATTR_DESC(pooled_width, AnyTraits<int>())},

  629.   {"spatial_scale", ATTR_DESC(spatial_scale, AnyTraits<float>())},

  630.   {"sample_num", ATTR_DESC(sample_num, AnyTraits<int>())}};

  631. 

  632. // ArgMaxD

  633. INPUT_MAP(ArgMaxD) = {{1, INPUT_DESC(x)}};

  634. ATTR_MAP(ArgMaxD) = {{"axis", ATTR_DESC(dimension, AnyTraits<int>())},

  635.                      {"output_type", ATTR_DESC(output_type, AnyTraits<GEType>())}};

  636. OUTPUT_MAP(ArgMaxD) = {{0, OUTPUT_DESC(y)}};

  637. 

  638. // ArgMinD

  639. INPUT_MAP(ArgMinD) = {{1, INPUT_DESC(x)}};

  640. ATTR_MAP(ArgMinD) = {{"axis", ATTR_DESC(dimension, AnyTraits<int>())},

  641.                      {"output_type", ATTR_DESC(output_type, AnyTraits<GEType>())}};

  642. OUTPUT_MAP(ArgMinD) = {{0, OUTPUT_DESC(y)}};

  643. 

  644. // ArgMaxWithValue

  645. INPUT_MAP(ArgMaxWithValue) = {{1, INPUT_DESC(x)}};

  646. ATTR_MAP(ArgMaxWithValue) = {{"axis", ATTR_DESC(dimension, AnyTraits<int>())},

  647.                              {"keep_dims", ATTR_DESC(keep_dims, AnyTraits<bool>())}};

  648. OUTPUT_MAP(ArgMaxWithValue) = {{0, OUTPUT_DESC(indice)}, {1, OUTPUT_DESC(values)}};

  649. 

  650. // ArgMinWithValue

  651. INPUT_MAP(ArgMinWithValue) = {{1, INPUT_DESC(x)}};

  652. ATTR_MAP(ArgMinWithValue) = {{"axis", ATTR_DESC(dimension, AnyTraits<int>())},

  653.                              {"keep_dims", ATTR_DESC(keep_dims, AnyTraits<bool>())}};

  654. OUTPUT_MAP(ArgMinWithValue) = {{0, OUTPUT_DESC(indice)}, {1, OUTPUT_DESC(values)}};

  655. 

  656. // ReduceAll

  657. INPUT_MAP(ReduceAll) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(axis)}};

  658. ATTR_MAP(ReduceAll) = {{"keep_dims", ATTR_DESC(keep_dims, AnyTraits<bool>())}};

  659. OUTPUT_MAP(ReduceAll) = {{0, OUTPUT_DESC(y)}};

  660. 

  661. // ReduceMeanD

  662. INPUT_MAP(ReduceMeanD) = {{1, INPUT_DESC(x)}};

  663. INPUT_ATTR_MAP(ReduceMeanD) = {

  664.   {2, ATTR_DESC(axis, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};

  665. ATTR_MAP(ReduceMeanD) = {{"keep_dims", ATTR_DESC(keep_dims, AnyTraits<bool>())}};

  666. OUTPUT_MAP(ReduceMeanD) = {{0, OUTPUT_DESC(y)}};

  667. 

  668. // HCOMAllreduce

  669. INPUT_MAP(HcomAllReduce) = {{1, INPUT_DESC(x)}};

  670. OUTPUT_MAP(HcomAllReduce) = {{0, OUTPUT_DESC(y)}};

  671. ATTR_MAP(HcomAllReduce) = {{"op", ATTR_DESC(reduction, AnyTraits<std::string>())},

  672.                            {"group", ATTR_DESC(group, AnyTraits<std::string>())},

  673.                            {"fusion", ATTR_DESC(fusion, AnyTraits<int>())}};

  674. 

  675. // HCOMBraodcast

  676. INPUT_MAP(HcomBroadcast) = EMPTY_INPUT_MAP;

  677. DYN_INPUT_MAP(HcomBroadcast) = {{1, DYN_INPUT_DESC(x)}};

  678. DYN_OUTPUT_MAP(HcomBroadcast) = {{0, DYN_OUTPUT_DESC(y)}};

  679. ATTR_MAP(HcomBroadcast) = {{"root_rank", ATTR_DESC(root_rank, AnyTraits<int>())},

  680.                            {"group", ATTR_DESC(group, AnyTraits<std::string>())}};

  681. 

  682. // HCOMAllreduce

  683. INPUT_MAP(HcomAllGather) = {{1, INPUT_DESC(x)}};

  684. OUTPUT_MAP(HcomAllGather) = {{0, OUTPUT_DESC(y)}};

  685. ATTR_MAP(HcomAllGather) = {{"group", ATTR_DESC(group, AnyTraits<std::string>())},

  686.                            {"rank_size", ATTR_DESC(rank_size, AnyTraits<int>())}};

  687. 

  688. // HCOMReduceScatter

  689. INPUT_MAP(HcomReduceScatter) = {{1, INPUT_DESC(x)}};

  690. OUTPUT_MAP(HcomReduceScatter) = {{0, OUTPUT_DESC(y)}};

  691. ATTR_MAP(HcomReduceScatter) = {{"group", ATTR_DESC(group, AnyTraits<std::string>())},

  692.                                {"op", ATTR_DESC(reduction, AnyTraits<std::string>())},

  693.                                {"rank_size", ATTR_DESC(rank_size, AnyTraits<int>())}};

  694. 

  695. // Variable

  696. INPUT_MAP(Variable) = {{1, INPUT_DESC(x)}};

  697. ATTR_MAP(Variable) = EMPTY_ATTR_MAP;

  698. 

  699. // ReluGrad

  700. INPUT_MAP(ReluGrad) = {{1, INPUT_DESC(gradients)}, {2, INPUT_DESC(features)}};

  701. ATTR_MAP(ReluGrad) = EMPTY_ATTR_MAP;

  702. OUTPUT_MAP(ReluGrad) = {{0, OUTPUT_DESC(backprops)}};

  703. 

  704. // FusedBatchNorm

  705. INPUT_MAP(FusedBatchNorm) = {

  706.   {1, INPUT_DESC(x)}, {2, INPUT_DESC(scale)}, {3, INPUT_DESC(b)}, {4, INPUT_DESC(mean)}, {5, INPUT_DESC(variance)}};

  707. ATTR_MAP(FusedBatchNorm) = {{"mode", ATTR_DESC(mode, AnyTraits<int64_t>())},

  708.                             {"momentum", ATTR_DESC(moving_average_fraction, AnyTraits<float>())},

  709.                             {"epsilon", ATTR_DESC(epsilon, AnyTraits<float>())}};

  710. OUTPUT_MAP(FusedBatchNorm) = {{0, OUTPUT_DESC(y)},

  711.                               {1, OUTPUT_DESC(running_mean)},

  712.                               {2, OUTPUT_DESC(running_variance)},

  713.                               {3, OUTPUT_DESC(save_mean)},

  714.                               {4, OUTPUT_DESC(save_inv_variance)}};

  715. 

  716. // FusedBatchNromGrad

  717. INPUT_MAP(FusedBatchNormGrad) = {{1, INPUT_DESC(dy)},

  718.                                  {2, INPUT_DESC(x)},

  719.                                  {3, INPUT_DESC(scale)},

  720.                                  {4, INPUT_DESC(save_mean)},

  721.                                  {5, INPUT_DESC(save_inv_variance)}};

  722. ATTR_MAP(FusedBatchNormGrad) = {{"momentum", ATTR_DESC(momentum, AnyTraits<float>())},

  723.                                 {"epsilon", ATTR_DESC(epsilon, AnyTraits<float>())}};

  724. OUTPUT_MAP(FusedBatchNormGrad) = {{0, OUTPUT_DESC(dx)}, {1, OUTPUT_DESC(bn_scale)}, {2, OUTPUT_DESC(bn_bias)}};

  725. 

  726. // BiasAddGrad

  727. INPUT_MAP(BiasAddGrad) = {{1, INPUT_DESC(x)}};

  728. ATTR_MAP(BiasAddGrad) = {{"data_format", ATTR_DESC(data_format, AnyTraits<std::string>())}};

  729. OUTPUT_MAP(BiasAddGrad) = {{0, OUTPUT_DESC(y)}};

  730. 

  731. // maxpoolgrad

  732. INPUT_MAP(MaxPoolGrad) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}, {3, INPUT_DESC(grad)}};

  733. ATTR_MAP(MaxPoolGrad) = {{"ksize", ATTR_DESC(ksize, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},

  734.                          {"strides", ATTR_DESC(strides, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},

  735.                          {"padding", ATTR_DESC(padding, AnyTraits<std::string>())}};

  736. OUTPUT_MAP(MaxPoolGrad) = {{0, OUTPUT_DESC(y)}};

  737. 

  738. // avgpoolgrad

  739. INPUT_MAP(AvgPoolGrad) = {{1, INPUT_DESC(orig_input_shape)}, {2, INPUT_DESC(input_grad)}};

  740. ATTR_MAP(AvgPoolGrad) = {{"ksize", ATTR_DESC(ksize, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},

  741.                          {"strides", ATTR_DESC(strides, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},

  742.                          {"padding", ATTR_DESC(padding, AnyTraits<std::string>())},

  743.                          {"data_format", ATTR_DESC(data_format, AnyTraits<std::string>())}};

  744. OUTPUT_MAP(AvgPoolGrad) = {{0, OUTPUT_DESC(out_grad)}};

  745. 

  746. // MaxPoolWithArgmax

  747. INPUT_MAP(MaxPoolWithArgmax) = {{1, INPUT_DESC(x)}};

  748. ATTR_MAP(MaxPoolWithArgmax) = {{"ksize", ATTR_DESC(ksize, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},

  749.                                {"strides", ATTR_DESC(strides, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},

  750.                                {"padding", ATTR_DESC(padding, AnyTraits<std::string>())}};

  751. OUTPUT_MAP(MaxPoolWithArgmax) = {{0, OUTPUT_DESC(y)}, {1, OUTPUT_DESC(argmax)}};

  752. 

  753. // MaxPoolGradWithArgmax

  754. INPUT_MAP(MaxPoolGradWithArgmax) = {

  755.   {1, INPUT_DESC(x)},

  756.   {2, INPUT_DESC(grad)},

  757.   {3, INPUT_DESC(argmax)},

  758. };

  759. ATTR_MAP(MaxPoolGradWithArgmax) = {{"ksize", ATTR_DESC(ksize, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},

  760.                                    {"strides", ATTR_DESC(strides, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},

  761.                                    {"padding", ATTR_DESC(padding, AnyTraits<std::string>())}};

  762. OUTPUT_MAP(MaxPoolGradWithArgmax) = {{0, OUTPUT_DESC(y)}};

  763. 

  764. // Conv2D

  765. INPUT_MAP(Conv2D) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(filter)}};

  766. ATTR_MAP(Conv2D) = {

  767.   {"stride", ATTR_DESC(strides, "pad", AnyTraits<std::vector<int64_t>>())},

  768.   {"pad_list", ATTR_DESC(pads, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},

  769.   {"dilation", ATTR_DESC(dilations, "pad", AnyTraits<std::vector<int64_t>>())},

  770. };

  771. OUTPUT_MAP(Conv2D) = {{0, OUTPUT_DESC(y)}};

  772. 

  773. // Conv2DBackpropInputD

  774. INPUT_MAP(Conv2DBackpropInputD) = {{1, INPUT_DESC(out_backprop)}, {2, INPUT_DESC(filters)}};

  775. INPUT_ATTR_MAP(Conv2DBackpropInputD) = {

  776.   {3, ATTR_DESC(input_sizes, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};

  777. ATTR_MAP(Conv2DBackpropInputD) = {

  778.   {"pad_list", ATTR_DESC(pads, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},

  779.   {"stride", ATTR_DESC(strides, "strides", AnyTraits<std::vector<int64_t>>())},

  780.   {"dilation", ATTR_DESC(dilations, "pad", AnyTraits<std::vector<int64_t>>())},

  781. };

  782. OUTPUT_MAP(Conv2DBackpropInputD) = {{0, OUTPUT_DESC(y)}};

  783. 

  784. // Conv2DBackpropFilterD

  785. INPUT_MAP(Conv2DBackpropFilterD) = {{1, INPUT_DESC(out_backprop)}, {2, INPUT_DESC(x)}};

  786. INPUT_ATTR_MAP(Conv2DBackpropFilterD) = {

  787.   {3, ATTR_DESC(filter_sizes, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};

  788. ATTR_MAP(Conv2DBackpropFilterD) = {

  789.   {"pad_list", ATTR_DESC(pads, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},

  790.   {"stride", ATTR_DESC(strides, "strides", AnyTraits<std::vector<int64_t>>())},

  791.   {"dilation", ATTR_DESC(dilations, "pad", AnyTraits<std::vector<int64_t>>())},

  792. };

  793. OUTPUT_MAP(Conv2DBackpropFilterD) = {{0, OUTPUT_DESC(y)}};

  794. 

  795. // DepthwiseConv2D

  796. INPUT_MAP(DepthwiseConv2D) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(filter)}};

  797. ATTR_MAP(DepthwiseConv2D) = {

  798.   {"stride", ATTR_DESC(strides, "pad", AnyTraits<std::vector<int64_t>>())},

  799.   {"pads", ATTR_DESC(pads, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},

  800.   {"dilation", ATTR_DESC(dilations, "pad", AnyTraits<std::vector<int64_t>>())},

  801.   {"data_format", ATTR_DESC(data_format, AnyTraits<std::string>())},

  802. };

  803. OUTPUT_MAP(DepthwiseConv2D) = {{0, OUTPUT_DESC(y)}};

  804. 

  805. // DepthwiseConv2DBackpropInputD

  806. INPUT_MAP(DepthwiseConv2DBackpropInputD) = {{2, INPUT_DESC(filter)}, {3, INPUT_DESC(out_backprop)}};

  807. INPUT_ATTR_MAP(DepthwiseConv2DBackpropInputD) = {

  808.   {1, ATTR_DESC(input_size, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};

  809. ATTR_MAP(DepthwiseConv2DBackpropInputD) = {

  810.   {"stride", ATTR_DESC(strides, "pad", AnyTraits<std::vector<int64_t>>())},

  811.   {"pads", ATTR_DESC(pads, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},

  812.   {"dilation", ATTR_DESC(dilations, "pad", AnyTraits<std::vector<int64_t>>())},

  813. };

  814. OUTPUT_MAP(DepthwiseConv2DBackpropInputD) = {{0, OUTPUT_DESC(input_grad)}};

  815. 

  816. // DepthwiseConv2DBackpropFilterD

  817. INPUT_MAP(DepthwiseConv2DBackpropFilterD) = {{1, INPUT_DESC(input)}, {3, INPUT_DESC(out_backprop)}};

  818. INPUT_ATTR_MAP(DepthwiseConv2DBackpropFilterD) = {

  819.   {2, ATTR_DESC(filter_size, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};

  820. ATTR_MAP(DepthwiseConv2DBackpropFilterD) = {

  821.   {"stride", ATTR_DESC(strides, "pad", AnyTraits<std::vector<int64_t>>())},

  822.   {"pads", ATTR_DESC(pads, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},

  823.   {"dilation", ATTR_DESC(dilations, "pad", AnyTraits<std::vector<int64_t>>())},

  824. };

  825. OUTPUT_MAP(DepthwiseConv2DBackpropFilterD) = {{0, OUTPUT_DESC(filter_grad)}};

  826. 

  827. // MatMul

  828. INPUT_MAP(MatMul) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};

  829. ATTR_MAP(MatMul) = {{"transpose_a", ATTR_DESC(transpose_a, AnyTraits<bool>())},

  830.                     {"transpose_b", ATTR_DESC(transpose_b, AnyTraits<bool>())}};

  831. OUTPUT_MAP(MatMul) = {{0, OUTPUT_DESC(y)}};

  832. 

  833. // Merge

  834. INPUT_MAP(Merge) = EMPTY_INPUT_MAP;

  835. DYN_INPUT_MAP(Merge) = {{1, DYN_INPUT_DESC(x)}};

  836. ATTR_MAP(Merge) = EMPTY_ATTR_MAP;

  837. OUTPUT_MAP(Merge) = {{0, OUTPUT_DESC(y)}, {1, OUTPUT_DESC(value_index)}};

  838. 

  839. // Switch

  840. INPUT_MAP(Switch) = {{1, INPUT_DESC(data)}, {2, INPUT_DESC(pred)}};

  841. OUTPUT_MAP(Switch) = {{0, OUTPUT_DESC(output_false)}, {1, OUTPUT_DESC(output_true)}};

  842. ATTR_MAP(Switch) = EMPTY_ATTR_MAP;

  843. 

  844. // AddN

  845. INPUT_MAP(AddN) = EMPTY_INPUT_MAP;

  846. DYN_INPUT_MAP(AddN) = {{1, DYN_INPUT_DESC(x)}};

  847. ATTR_MAP(AddN) = {{"n", ATTR_DESC(N, AnyTraits<int64_t>())}};

  848. OUTPUT_MAP(AddN) = {{0, OUTPUT_DESC(y)}};

  849. 

  850. // Mul

  851. INPUT_MAP(Mul) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};

  852. ATTR_MAP(Mul) = EMPTY_ATTR_MAP;

  853. OUTPUT_MAP(Mul) = {{0, OUTPUT_DESC(y)}};

  854. 

  855. // RealDiv

  856. INPUT_MAP(RealDiv) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};

  857. ATTR_MAP(RealDiv) = EMPTY_ATTR_MAP;

  858. OUTPUT_MAP(RealDiv) = {{0, OUTPUT_DESC(y)}};

  859. 

  860. // Cast

  861. INPUT_MAP(Cast) = {{1, INPUT_DESC(x)}};

  862. INPUT_ATTR_MAP(Cast) = {{2, ATTR_DESC(dst_type, AnyTraits<GEType>())}};

  863. ATTR_MAP(Cast) = {{"Truncate", ATTR_DESC(truncate, AnyTraits<bool>())}};

  864. OUTPUT_MAP(Cast) = {{0, OUTPUT_DESC(y)}};

  865. 

  866. // Reciprocal

  867. INPUT_MAP(Reciprocal) = {{1, INPUT_DESC(x)}};

  868. ATTR_MAP(Reciprocal) = EMPTY_ATTR_MAP;

  869. OUTPUT_MAP(Reciprocal) = {{0, OUTPUT_DESC(y)}};

  870. 

  871. // Sub

  872. INPUT_MAP(Sub) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};

  873. ATTR_MAP(Sub) = EMPTY_ATTR_MAP;

  874. OUTPUT_MAP(Sub) = {{0, OUTPUT_DESC(y)}};

  875. 

  876. // SplitD

  877. INPUT_MAP(SplitD) = {{1, INPUT_DESC(value)}};

  878. ATTR_MAP(SplitD) = {{"axis", ATTR_DESC(split_dim, AnyTraits<int>())},

  879.                     {"output_num", ATTR_DESC(num_split, AnyTraits<int>())}};

  880. DYN_OUTPUT_MAP(SplitD) = {{0, DYN_OUTPUT_DESC(output)}};

  881. 

  882. // Neg

  883. INPUT_MAP(Neg) = {{1, INPUT_DESC(x)}};

  884. ATTR_MAP(Neg) = EMPTY_ATTR_MAP;

  885. OUTPUT_MAP(Neg) = {{0, OUTPUT_DESC(y)}};

  886. 

  887. // Transpose

  888. INPUT_MAP(TransposeD) = {{1, INPUT_DESC(x)}};

  889. INPUT_ATTR_MAP(TransposeD) = {{2, ATTR_DESC(perm, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())}};

  890. ATTR_MAP(TransposeD) = EMPTY_ATTR_MAP;

  891. // Do not set Transpose operator output descriptor

  892. 

  893. // DropOutGenMask

  894. INPUT_MAP(DropOutGenMask) = {{1, INPUT_DESC(shape)}, {2, INPUT_DESC(prob)}};

  895. ATTR_MAP(DropOutGenMask) = {{"seed", ATTR_DESC(seed, AnyTraits<int64_t>())},

  896.                             {"seed2", ATTR_DESC(seed2, AnyTraits<int64_t>())}};

  897. OUTPUT_MAP(DropOutGenMask) = {{0, OUTPUT_DESC(y)}};

  898. 

  899. // Pack

  900. INPUT_MAP(Pack) = EMPTY_INPUT_MAP;

  901. DYN_INPUT_MAP(Pack) = {{1, DYN_INPUT_DESC(x)}};

  902. ATTR_MAP(Pack) = {{"num", ATTR_DESC(N, AnyTraits<int>())}, {"axis", ATTR_DESC(axis, AnyTraits<int>())}};

  903. OUTPUT_MAP(Pack) = {{0, OUTPUT_DESC(y)}};

  904. 

  905. // ConcatD

  906. INPUT_MAP(ConcatD) = EMPTY_INPUT_MAP;

  907. DYN_INPUT_MAP(ConcatD) = {{1, DYN_INPUT_DESC(input_values)}};

  908. ATTR_MAP(ConcatD) = {

  909.   {"axis", ATTR_DESC(concat_dim, AnyTraits<int>())},

  910.   {"inputNums", ATTR_DESC(N, AnyTraits<int>())},

  911. };

  912. OUTPUT_MAP(ConcatD) = {{0, OUTPUT_DESC(output_data)}};

  913. 

  914. // Less

  915. INPUT_MAP(Less) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};

  916. ATTR_MAP(Less) = EMPTY_ATTR_MAP;

  917. OUTPUT_MAP(Less) = {{0, OUTPUT_DESC(y)}};

  918. 

  919. // Rsqrt

  920. INPUT_MAP(Rsqrt) = {{1, INPUT_DESC(x)}};

  921. ATTR_MAP(Rsqrt) = EMPTY_ATTR_MAP;

  922. OUTPUT_MAP(Rsqrt) = {{0, OUTPUT_DESC(y)}};

  923. 

  924. // Sqrt

  925. INPUT_MAP(Sqrt) = {{1, INPUT_DESC(x)}};

  926. ATTR_MAP(Sqrt) = EMPTY_ATTR_MAP;

  927. OUTPUT_MAP(Sqrt) = {{0, OUTPUT_DESC(y)}};

  928. 

  929. // Square

  930. INPUT_MAP(Square) = {{1, INPUT_DESC(x)}};

  931. ATTR_MAP(Square) = EMPTY_ATTR_MAP;

  932. OUTPUT_MAP(Square) = {{0, OUTPUT_DESC(y)}};

  933. 

  934. // Tanh

  935. INPUT_MAP(Tanh) = {{1, INPUT_DESC(x)}};

  936. ATTR_MAP(Tanh) = EMPTY_ATTR_MAP;

  937. OUTPUT_MAP(Tanh) = {{0, OUTPUT_DESC(y)}};

  938. 

  939. // TanhGrad

  940. INPUT_MAP(TanhGrad) = {{1, INPUT_DESC(y)}, {2, INPUT_DESC(dy)}};

  941. ATTR_MAP(TanhGrad) = EMPTY_ATTR_MAP;

  942. OUTPUT_MAP(TanhGrad) = {{0, OUTPUT_DESC(z)}};

  943. 

  944. // ReduceMinD

  945. INPUT_MAP(ReduceMinD) = {{1, INPUT_DESC(x)}};

  946. INPUT_ATTR_MAP(ReduceMinD) = {

  947.   {2, ATTR_DESC(axis, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};

  948. ATTR_MAP(ReduceMinD) = {{"keep_dims", ATTR_DESC(keep_dims, AnyTraits<bool>())}};

  949. OUTPUT_MAP(ReduceMinD) = {{0, OUTPUT_DESC(y)}};

  950. 

  951. // ReduceMaxD

  952. INPUT_MAP(ReduceMaxD) = {{1, INPUT_DESC(x)}};

  953. INPUT_ATTR_MAP(ReduceMaxD) = {

  954.   {2, ATTR_DESC(axis, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};

  955. ATTR_MAP(ReduceMaxD) = {{"keep_dims", ATTR_DESC(keep_dims, AnyTraits<bool>())}};

  956. OUTPUT_MAP(ReduceMaxD) = {{0, OUTPUT_DESC(y)}};

  957. 

  958. // Maximum

  959. INPUT_MAP(Maximum) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};

  960. ATTR_MAP(Maximum) = EMPTY_ATTR_MAP;

  961. OUTPUT_MAP(Maximum) = {{0, OUTPUT_DESC(y)}};

  962. 

  963. // Minimum

  964. INPUT_MAP(Minimum) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};

  965. ATTR_MAP(Minimum) = EMPTY_ATTR_MAP;

  966. OUTPUT_MAP(Minimum) = {{0, OUTPUT_DESC(y)}};

  967. 

  968. // MaximumGrad

  969. INPUT_MAP(MaximumGrad) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}, {3, INPUT_DESC(grads)}};

  970. ATTR_MAP(MaximumGrad) = {{"grad_x", ATTR_DESC(grad_x, AnyTraits<bool>())},

  971.                          {"grad_y", ATTR_DESC(grad_y, AnyTraits<bool>())}};

  972. OUTPUT_MAP(MaximumGrad) = {{0, OUTPUT_DESC(y1)}, {1, OUTPUT_DESC(y2)}};

  973. 

  974. // MinimumGrad

  975. INPUT_MAP(MinimumGrad) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}, {3, INPUT_DESC(grads)}};

  976. ATTR_MAP(MinimumGrad) = {{"grad_x", ATTR_DESC(grad_x, AnyTraits<bool>())},

  977.                          {"grad_y", ATTR_DESC(grad_y, AnyTraits<bool>())}};

  978. OUTPUT_MAP(MinimumGrad) = {{0, OUTPUT_DESC(y1)}, {1, OUTPUT_DESC(y2)}};

  979. 

  980. // Pow

  981. INPUT_MAP(Pow) = {

  982.   {1, INPUT_DESC(x1)},

  983.   {2, INPUT_DESC(x2)},

  984. };

  985. ATTR_MAP(Pow) = EMPTY_ATTR_MAP;

  986. OUTPUT_MAP(Pow) = {{0, OUTPUT_DESC(y)}};

  987. 

  988. // Equal

  989. INPUT_MAP(Equal) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};

  990. ATTR_MAP(Equal) = EMPTY_ATTR_MAP;

  991. OUTPUT_MAP(Equal) = {{0, OUTPUT_DESC(y)}};

  992. 

  993. // NotEqual

  994. INPUT_MAP(NotEqual) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};

  995. ATTR_MAP(NotEqual) = EMPTY_ATTR_MAP;

  996. OUTPUT_MAP(NotEqual) = {{0, OUTPUT_DESC(y)}};

  997. 

  998. // Log

  999. INPUT_MAP(Log) = {{1, INPUT_DESC(x)}};

  1000. ATTR_MAP(Log) = EMPTY_ATTR_MAP;

  1001. OUTPUT_MAP(Log) = {{0, OUTPUT_DESC(y)}};

  1002. 

  1003. // LogicalAnd

  1004. INPUT_MAP(LogicalAnd) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};

  1005. ATTR_MAP(LogicalAnd) = EMPTY_ATTR_MAP;

  1006. OUTPUT_MAP(LogicalAnd) = {{0, OUTPUT_DESC(y)}};

  1007. 

  1008. // LogicalOr

  1009. INPUT_MAP(LogicalOr) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};

  1010. ATTR_MAP(LogicalOr) = EMPTY_ATTR_MAP;

  1011. OUTPUT_MAP(LogicalOr) = {{0, OUTPUT_DESC(y)}};

  1012. 

  1013. // LogicalNot

  1014. INPUT_MAP(LogicalNot) = {{1, INPUT_DESC(x)}};

  1015. ATTR_MAP(LogicalNot) = EMPTY_ATTR_MAP;

  1016. OUTPUT_MAP(LogicalNot) = {{0, OUTPUT_DESC(y)}};

  1017. 

  1018. // Greater

  1019. INPUT_MAP(Greater) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};

  1020. ATTR_MAP(Greater) = EMPTY_ATTR_MAP;

  1021. OUTPUT_MAP(Greater) = {{0, OUTPUT_DESC(y)}};

  1022. 

  1023. // LogSoftmaxGrad

  1024. INPUT_MAP(LogSoftmaxGrad) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(grad)}};

  1025. ATTR_MAP(LogSoftmaxGrad) = {

  1026.   {"axis", ATTR_DESC(axis, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};

  1027. OUTPUT_MAP(LogSoftmaxGrad) = {{0, OUTPUT_DESC(y)}};

  1028. 

  1029. // Select

  1030. INPUT_MAP(Select) = {{1, INPUT_DESC(condition)}, {2, INPUT_DESC(x1)}, {3, INPUT_DESC(x2)}};

  1031. ATTR_MAP(Select) = EMPTY_ATTR_MAP;

  1032. OUTPUT_MAP(Select) = {{0, OUTPUT_DESC(y)}};

  1033. 

  1034. // LessEqual

  1035. INPUT_MAP(LessEqual) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};

  1036. ATTR_MAP(LessEqual) = EMPTY_ATTR_MAP;

  1037. OUTPUT_MAP(LessEqual) = {{0, OUTPUT_DESC(y)}};

  1038. 

  1039. // LogSoftmax

  1040. INPUT_MAP(LogSoftmax) = {{1, INPUT_DESC(logits)}};

  1041. ATTR_MAP(LogSoftmax) = {

  1042.   {"axis", ATTR_DESC(axis, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};

  1043. OUTPUT_MAP(LogSoftmax) = {{0, OUTPUT_DESC(logsoftmax)}};

  1044. 

  1045. // RandomChoiceWithMask

  1046. INPUT_MAP(RandomChoiceWithMask) = {{1, INPUT_DESC(x)}};

  1047. ATTR_MAP(RandomChoiceWithMask) = {{"count", ATTR_DESC(count, AnyTraits<int64_t>())},

  1048.                                   {"seed", ATTR_DESC(seed, AnyTraits<int64_t>())},

  1049.                                   {"seed2", ATTR_DESC(seed2, AnyTraits<int64_t>())}};

  1050. OUTPUT_MAP(RandomChoiceWithMask) = {{0, OUTPUT_DESC(y)}, {1, OUTPUT_DESC(mask)}};

  1051. 

  1052. // TruncatedNormal

  1053. INPUT_MAP(TruncatedNormal) = {{1, INPUT_DESC(shape)}};

  1054. ATTR_MAP(TruncatedNormal) = {{"seed", ATTR_DESC(seed, AnyTraits<int64_t>())},

  1055.                              {"seed2", ATTR_DESC(seed2, AnyTraits<int64_t>())}};

  1056. OUTPUT_MAP(TruncatedNormal) = {{0, OUTPUT_DESC(y)}};

  1057. 

  1058. // StridedSliceGrad

  1059. INPUT_MAP(StridedSliceGrad) = {

  1060.   {1, INPUT_DESC(dy)}, {2, INPUT_DESC(shape)}, {3, INPUT_DESC(begin)}, {4, INPUT_DESC(end)}, {5, INPUT_DESC(strides)}};

  1061. ATTR_MAP(StridedSliceGrad) = {{"begin_mask", ATTR_DESC(begin_mask, AnyTraits<int64_t>())},

  1062.                               {"end_mask", ATTR_DESC(end_mask, AnyTraits<int64_t>())},

  1063.                               {"ellipsis_mask", ATTR_DESC(ellipsis_mask, AnyTraits<int64_t>())},

  1064.                               {"new_axis_mask", ATTR_DESC(new_axis_mask, AnyTraits<int64_t>())},

  1065.                               {"shrink_axis_mask", ATTR_DESC(shrink_axis_mask, AnyTraits<int64_t>())}};

  1066. OUTPUT_MAP(StridedSliceGrad) = {{0, OUTPUT_DESC(output)}};

  1067. 

  1068. // Gelu

  1069. INPUT_MAP(Gelu) = {{1, INPUT_DESC(x)}};

  1070. ATTR_MAP(Gelu) = EMPTY_ATTR_MAP;

  1071. OUTPUT_MAP(Gelu) = {{0, OUTPUT_DESC(y)}};

  1072. 

  1073. // GeluGrad

  1074. INPUT_MAP(GeluGrad) = {{1, INPUT_DESC(dy)}, {2, INPUT_DESC(x)}, {3, INPUT_DESC(y)}};

  1075. ATTR_MAP(GeluGrad) = EMPTY_ATTR_MAP;

  1076. OUTPUT_MAP(GeluGrad) = {{0, OUTPUT_DESC(z)}};

  1077. 

  1078. // StridedSlice

  1079. INPUT_MAP(StridedSlice) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(begin)}, {3, INPUT_DESC(end)}, {4, INPUT_DESC(strides)}};

  1080. ATTR_MAP(StridedSlice) = {{"begin_mask", ATTR_DESC(begin_mask, AnyTraits<int64_t>())},

  1081.                           {"end_mask", ATTR_DESC(end_mask, AnyTraits<int64_t>())},

  1082.                           {"ellipsis_mask", ATTR_DESC(ellipsis_mask, AnyTraits<int64_t>())},

  1083.                           {"new_axis_mask", ATTR_DESC(new_axis_mask, AnyTraits<int64_t>())},

  1084.                           {"shrink_axis_mask", ATTR_DESC(shrink_axis_mask, AnyTraits<int64_t>())}};

  1085. OUTPUT_MAP(StridedSlice) = {{0, OUTPUT_DESC(y)}};

  1086. 

  1087. // UnsortedSegmentSum

  1088. INPUT_MAP(UnsortedSegmentSumD) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(segment_ids)}};

  1089. INPUT_ATTR_MAP(UnsortedSegmentSumD) = {{3, ATTR_DESC(num_segments, AnyTraits<int64_t>())}};

  1090. ATTR_MAP(UnsortedSegmentSumD) = EMPTY_ATTR_MAP;

  1091. OUTPUT_MAP(UnsortedSegmentSumD) = {{0, OUTPUT_DESC(y)}};

  1092. 

  1093. // ExpandDims

  1094. INPUT_MAP(ExpandDims) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(axis)}};

  1095. ATTR_MAP(ExpandDims) = EMPTY_ATTR_MAP;

  1096. OUTPUT_MAP(ExpandDims) = {{0, OUTPUT_DESC(y)}};

  1097. 

  1098. // Squeeze

  1099. INPUT_MAP(Squeeze) = {{1, INPUT_DESC(x)}};

  1100. ATTR_MAP(Squeeze) = {{"axis", ATTR_DESC(axis, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())}};

  1101. OUTPUT_MAP(Squeeze) = {{0, OUTPUT_DESC(y)}};

  1102. 

  1103. // SGD

  1104. INPUT_MAP(SGD) = {{1, INPUT_DESC(parameters)}, {2, INPUT_DESC(gradient)}, {3, INPUT_DESC(learning_rate)},

  1105.                   {4, INPUT_DESC(accum)},      {5, INPUT_DESC(momentum)}, {6, INPUT_DESC(stat)}};

  1106. ATTR_MAP(SGD) = {{"dampening", ATTR_DESC(dampening, AnyTraits<float>())},

  1107.                  {"weight_decay", ATTR_DESC(weight_decay, AnyTraits<float>())},

  1108.                  {"nesterov", ATTR_DESC(nesterov, AnyTraits<bool>())}};

  1109. OUTPUT_MAP(SGD) = {{0, OUTPUT_DESC(parameters)}};

  1110. 

  1111. // LayerNorm

  1112. INPUT_MAP(LayerNorm) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(gamma)}, {3, INPUT_DESC(beta)}};

  1113. ATTR_MAP(LayerNorm) = {{"begin_norm_axis", ATTR_DESC(begin_norm_axis, AnyTraits<int>())},

  1114.                        {"begin_params_axis", ATTR_DESC(begin_params_axis, AnyTraits<int>())}};

  1115. OUTPUT_MAP(LayerNorm) = {{0, OUTPUT_DESC(y)}, {1, OUTPUT_DESC(mean)}, {2, OUTPUT_DESC(variance)}};

  1116. 

  1117. // LayerNormGrad

  1118. INPUT_MAP(LayerNormGrad) = {

  1119.   {1, INPUT_DESC(x)}, {2, INPUT_DESC(dy)}, {3, INPUT_DESC(variance)}, {4, INPUT_DESC(mean)}, {5, INPUT_DESC(gamma)}};

  1120. ATTR_MAP(LayerNormGrad) = EMPTY_ATTR_MAP;

  1121. OUTPUT_MAP(LayerNormGrad) = {{0, OUTPUT_DESC(pd_x)}, {1, OUTPUT_DESC(pd_gamma)}, {2, OUTPUT_DESC(pd_beta)}};

  1122. 

  1123. // BatchMatMul

  1124. INPUT_MAP(BatchMatMul) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};

  1125. ATTR_MAP(BatchMatMul) = {{"transpose_x1", ATTR_DESC(adj_x, AnyTraits<bool>())},

  1126.                          {"transpose_x2", ATTR_DESC(adj_y, AnyTraits<bool>())}};

  1127. OUTPUT_MAP(BatchMatMul) = {{0, OUTPUT_DESC(y)}};

  1128. 

  1129. // DropoutDoMask

  1130. INPUT_MAP(DropOutDoMask) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(mask)}, {3, INPUT_DESC(keep_prob)}};

  1131. ATTR_MAP(DropOutDoMask) = EMPTY_ATTR_MAP;

  1132. OUTPUT_MAP(DropOutDoMask) = {{0, OUTPUT_DESC(y)}};

  1133. 

  1134. // NPUGetFloatStatus

  1135. INPUT_MAP(NPUGetFloatStatus) = {{1, INPUT_DESC(addr)}};

  1136. OUTPUT_MAP(NPUGetFloatStatus) = {{0, OUTPUT_DESC(data)}};

  1137. ATTR_MAP(NPUGetFloatStatus) = EMPTY_ATTR_MAP;

  1138. 

  1139. // NPUAllocFloatStatus

  1140. INPUT_MAP(NPUAllocFloatStatus) = EMPTY_INPUT_MAP;

  1141. ATTR_MAP(NPUAllocFloatStatus) = EMPTY_ATTR_MAP;

  1142. OUTPUT_MAP(NPUAllocFloatStatus) = {{0, OUTPUT_DESC(data)}};

  1143. 

  1144. // NPUClearFloatStatus

  1145. INPUT_MAP(NPUClearFloatStatus) = {{1, INPUT_DESC(addr)}};

  1146. OUTPUT_MAP(NPUClearFloatStatus) = {{0, OUTPUT_DESC(data)}};

  1147. ATTR_MAP(NPUClearFloatStatus) = EMPTY_ATTR_MAP;

  1148. 

  1149. // Abs

  1150. INPUT_MAP(Abs) = {{1, INPUT_DESC(x)}};

  1151. ATTR_MAP(Abs) = EMPTY_ATTR_MAP;

  1152. OUTPUT_MAP(Abs) = {{0, OUTPUT_DESC(y)}};

  1153. 

  1154. // AbsGrad

  1155. INPUT_MAP(AbsGrad) = {{1, INPUT_DESC(y)}, {2, INPUT_DESC(dy)}};

  1156. ATTR_MAP(AbsGrad) = EMPTY_ATTR_MAP;

  1157. OUTPUT_MAP(AbsGrad) = {{0, OUTPUT_DESC(z)}};

  1158. 

  1159. // BinaryCrossEntropy

  1160. INPUT_MAP(BinaryCrossEntropy) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(y)}, {3, INPUT_DESC(weight)}};

  1161. ATTR_MAP(BinaryCrossEntropy) = {{"reduction", ATTR_DESC(reduction, AnyTraits<std::string>())}};

  1162. OUTPUT_MAP(BinaryCrossEntropy) = {{0, OUTPUT_DESC(output)}};

  1163. 

  1164. // BinaryCrossEntropyGrad

  1165. INPUT_MAP(BinaryCrossEntropyGrad) = {

  1166.   {1, INPUT_DESC(x)}, {2, INPUT_DESC(y)}, {3, INPUT_DESC(grad_output)}, {4, INPUT_DESC(weight)}};

  1167. ATTR_MAP(BinaryCrossEntropyGrad) = {{"reduction", ATTR_DESC(reduction, AnyTraits<std::string>())}};

  1168. OUTPUT_MAP(BinaryCrossEntropyGrad) = {{0, OUTPUT_DESC(output)}};

  1169. 

  1170. // SparseApplyAdagradD

  1171. INPUT_MAP(SparseApplyAdagradD) = {

  1172.   {1, INPUT_DESC(var)}, {2, INPUT_DESC(accum)}, {3, INPUT_DESC(grad)}, {4, INPUT_DESC(indices)}};

  1173. ATTR_MAP(SparseApplyAdagradD) = {{"lr", ATTR_DESC(lr, AnyTraits<float>())},

  1174.                                  {"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())}};

  1175. OUTPUT_MAP(SparseApplyAdagradD) = {{0, OUTPUT_DESC(var)}};

  1176. 

  1177. // SpaceToDepth

  1178. INPUT_MAP(SpaceToDepth) = {{1, INPUT_DESC(x)}};

  1179. ATTR_MAP(SpaceToDepth) = {{"block_size", ATTR_DESC(block_size, AnyTraits<int64_t>())}};

  1180. OUTPUT_MAP(SpaceToDepth) = {{0, OUTPUT_DESC(y)}};

  1181. 

  1182. // DepthToSpace

  1183. INPUT_MAP(DepthToSpace) = {{1, INPUT_DESC(x)}};

  1184. ATTR_MAP(DepthToSpace) = {{"block_size", ATTR_DESC(block_size, AnyTraits<int64_t>())}};

  1185. OUTPUT_MAP(DepthToSpace) = {{0, OUTPUT_DESC(y)}};

  1186. 

  1187. // Sign

  1188. INPUT_MAP(Sign) = {{1, INPUT_DESC(x)}};

  1189. ATTR_MAP(Sign) = EMPTY_ATTR_MAP;

  1190. OUTPUT_MAP(Sign) = {{0, OUTPUT_DESC(y)}};

  1191. 

  1192. // Round

  1193. INPUT_MAP(Round) = {{1, INPUT_DESC(x)}};

  1194. ATTR_MAP(Round) = EMPTY_ATTR_MAP;

  1195. OUTPUT_MAP(Round) = {{0, OUTPUT_DESC(y)}};

  1196. 

  1197. // ApplyFtrl

  1198. INPUT_MAP(ApplyFtrl) = {{1, INPUT_DESC(var)},  {2, INPUT_DESC(accum)},   {3, INPUT_DESC(linear)},

  1199.                         {4, INPUT_DESC(grad)}, {5, INPUT_DESC(lr)},      {6, INPUT_DESC(l1)},

  1200.                         {7, INPUT_DESC(l2)},   {8, INPUT_DESC(lr_power)}};

  1201. ATTR_MAP(ApplyFtrl) = {{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())}};

  1202. OUTPUT_MAP(ApplyFtrl) = {{0, OUTPUT_DESC(var)}};

  1203. 

  1204. // Diag

  1205. INPUT_MAP(Diag) = {{1, INPUT_DESC(x)}};

  1206. ATTR_MAP(Diag) = EMPTY_ATTR_MAP;

  1207. OUTPUT_MAP(Diag) = {{0, OUTPUT_DESC(y)}};

  1208. 

  1209. // DiagPart

  1210. INPUT_MAP(DiagPart) = {{1, INPUT_DESC(x)}};

  1211. ATTR_MAP(DiagPart) = EMPTY_ATTR_MAP;

  1212. OUTPUT_MAP(DiagPart) = {{0, OUTPUT_DESC(y)}};

  1213. 

  1214. // SpaceToBatchD

  1215. INPUT_MAP(SpaceToBatchD) = {{1, INPUT_DESC(x)}};

  1216. ATTR_MAP(SpaceToBatchD) = {

  1217.   {"block_size", ATTR_DESC(block_size, AnyTraits<int64_t>())},

  1218.   {"paddings", ATTR_DESC(paddings, AnyTraits<std::vector<std::vector<int64_t>>>(), AnyTraits<std::vector<int64_t>>())}};

  1219. OUTPUT_MAP(SpaceToBatchD) = {{0, OUTPUT_DESC(y)}};

  1220. 

  1221. // BatchToSpaceD

  1222. INPUT_MAP(BatchToSpaceD) = {{1, INPUT_DESC(x)}};

  1223. ATTR_MAP(BatchToSpaceD) = {

  1224.   {"block_size", ATTR_DESC(block_size, AnyTraits<int64_t>())},

  1225.   {"crops", ATTR_DESC(crops, AnyTraits<std::vector<std::vector<int64_t>>>(), AnyTraits<std::vector<int64_t>>())}};

  1226. OUTPUT_MAP(BatchToSpaceD) = {{0, OUTPUT_DESC(y)}};

  1227. 

  1228. // Atan2

  1229. INPUT_MAP(Atan2) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};

  1230. ATTR_MAP(Atan2) = EMPTY_ATTR_MAP;

  1231. OUTPUT_MAP(Atan2) = {{0, OUTPUT_DESC(y)}};

  1232. 

  1233. // ApplyRMSPropD

  1234. INPUT_MAP(ApplyRMSPropD) = {

  1235.   {1, INPUT_DESC(var)}, {2, INPUT_DESC(ms)}, {3, INPUT_DESC(mom)}, {4, INPUT_DESC(grad)}, {5, INPUT_DESC(lr)}};

  1236. INPUT_ATTR_MAP(ApplyRMSPropD) = {{6, ATTR_DESC(rho, AnyTraits<float>())},

  1237.                                  {7, ATTR_DESC(momentum, AnyTraits<float>())},

  1238.                                  {8, ATTR_DESC(epsilon, AnyTraits<float>())}};

  1239. ATTR_MAP(ApplyRMSPropD) = {{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())}};

  1240. OUTPUT_MAP(ApplyRMSPropD) = {{0, OUTPUT_DESC(var)}};

  1241. 

  1242. // ApplyCenteredRMSProp

  1243. INPUT_MAP(ApplyCenteredRMSProp) = {{1, INPUT_DESC(var)}, {2, INPUT_DESC(mg)},       {3, INPUT_DESC(ms)},

  1244.                                    {4, INPUT_DESC(mom)}, {5, INPUT_DESC(grad)},     {6, INPUT_DESC(lr)},

  1245.                                    {7, INPUT_DESC(rho)}, {8, INPUT_DESC(momentum)}, {9, INPUT_DESC(epsilon)}};

  1246. ATTR_MAP(ApplyCenteredRMSProp) = {{"use_locking", ATTR_DESC(use_locking, AnyTraits<bool>())}};

  1247. OUTPUT_MAP(ApplyCenteredRMSProp) = {{0, OUTPUT_DESC(var)}};

  1248. 

  1249. #ifdef ENABLE_GE

  1250. // Print

  1251. INPUT_MAP(Print) = EMPTY_INPUT_MAP;

  1252. DYN_INPUT_MAP(Print) = {{1, DYN_INPUT_DESC(x)}};

  1253. ATTR_MAP(Print) = EMPTY_ATTR_MAP;

  1254. #endif

  1255. }  // namespace transform

  1256. }  // namespace mindspore