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: 9f9af3c59a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '9f9af3c59a'
${ noResults }
mindspore/mindspore/ccsrc/transform/op_declare.h

479 lines
16 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. #ifndef TRANSFORM_OP_DECLARE_H_

  18. #define TRANSFORM_OP_DECLARE_H_

  19. 

  20. #include <string>

  21. #include <unordered_map>

  22. #include "transform/op_adapter.h"

  23. 

  24. namespace mindspore {

  25. namespace transform {

  26. #define DECLARE_OP_ADAPTER(T)                                        \

  27.   using T = ge::op::T;                                               \

  28.   template <>                                                        \

  29.   const std::unordered_map<int, InputDesc> OpAdapter<T>::input_map_; \

  30.   template <>                                                        \

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

  32. 

  33. #define DECLARE_OP_USE_OUTPUT(T) \

  34.   template <>                    \

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

  36. 

  37. #define DECLARE_OP_USE_ENUM(T) \

  38.   template <>                  \

  39.   const std::unordered_map<std::string, int> OpAdapter<T>::enum_map_;

  40. 

  41. #define DECLARE_OP_USE_INPUT_ATTR(T) \

  42.   template <>                        \

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

  44. 

  45. #define DECLARE_OP_USE_DYN_INPUT(T) \

  46.   template <>                       \

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

  48. 

  49. #define DECLARE_OP_USE_DYN_OUTPUT(T) \

  50.   template <>                        \

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

  52. 

  53. template <>

  54. std::unordered_map<std::string, std::unordered_map<int, std::string>> OpAdapter<ge::Operator>::cus_input_map_;

  55. template <>

  56. std::unordered_map<std::string, std::unordered_map<int, std::string>> OpAdapter<ge::Operator>::cus_output_map_;

  57. 

  58. DECLARE_OP_ADAPTER(GreaterEqual)

  59. DECLARE_OP_USE_OUTPUT(GreaterEqual)

  60. DECLARE_OP_ADAPTER(SliceD)

  61. DECLARE_OP_USE_INPUT_ATTR(SliceD)

  62. DECLARE_OP_USE_OUTPUT(SliceD)

  63. DECLARE_OP_ADAPTER(AssignAdd)

  64. DECLARE_OP_USE_OUTPUT(AssignAdd)

  65. DECLARE_OP_ADAPTER(AssignSub)

  66. DECLARE_OP_USE_OUTPUT(AssignSub)

  67. 

  68. DECLARE_OP_ADAPTER(ReduceMean)

  69. DECLARE_OP_ADAPTER(Multiply)

  70. DECLARE_OP_USE_OUTPUT(Multiply)

  71. 

  72. // ** Distributed Operations **

  73. DECLARE_OP_ADAPTER(HcomReduceScatter)

  74. DECLARE_OP_USE_OUTPUT(HcomReduceScatter)

  75. DECLARE_OP_ADAPTER(HcomBroadcast)

  76. DECLARE_OP_USE_DYN_INPUT(HcomBroadcast)

  77. DECLARE_OP_USE_DYN_OUTPUT(HcomBroadcast)

  78. DECLARE_OP_ADAPTER(HcomAllReduce)

  79. DECLARE_OP_USE_OUTPUT(HcomAllReduce)

  80. DECLARE_OP_ADAPTER(HcomAllGather)

  81. DECLARE_OP_USE_OUTPUT(HcomAllGather)

  82. DECLARE_OP_ADAPTER(Variable)

  83. DECLARE_OP_ADAPTER(ReluGrad)

  84. DECLARE_OP_USE_OUTPUT(ReluGrad)

  85. DECLARE_OP_ADAPTER(BiasAddGrad)

  86. DECLARE_OP_USE_OUTPUT(BiasAddGrad)

  87. DECLARE_OP_ADAPTER(MaxPoolWithArgmax)

  88. DECLARE_OP_USE_OUTPUT(MaxPoolWithArgmax)

  89. DECLARE_OP_ADAPTER(MaxPoolGradWithArgmax)

  90. DECLARE_OP_USE_OUTPUT(MaxPoolGradWithArgmax)

  91. DECLARE_OP_ADAPTER(Conv2D)

  92. DECLARE_OP_USE_ENUM(Conv2D)

  93. DECLARE_OP_USE_OUTPUT(Conv2D)

  94. DECLARE_OP_ADAPTER(ExtractImagePatches)

  95. DECLARE_OP_USE_OUTPUT(ExtractImagePatches)

  96. DECLARE_OP_ADAPTER(Conv2DBackpropInputD)

  97. DECLARE_OP_USE_ENUM(Conv2DBackpropInputD)

  98. DECLARE_OP_USE_INPUT_ATTR(Conv2DBackpropInputD)

  99. DECLARE_OP_USE_OUTPUT(Conv2DBackpropInputD)

  100. DECLARE_OP_ADAPTER(Conv2DBackpropFilterD)

  101. DECLARE_OP_USE_ENUM(Conv2DBackpropFilterD)

  102. DECLARE_OP_USE_INPUT_ATTR(Conv2DBackpropFilterD)

  103. DECLARE_OP_USE_OUTPUT(Conv2DBackpropFilterD)

  104. DECLARE_OP_ADAPTER(DepthwiseConv2D)

  105. DECLARE_OP_USE_ENUM(DepthwiseConv2D)

  106. DECLARE_OP_USE_OUTPUT(DepthwiseConv2D)

  107. DECLARE_OP_ADAPTER(DepthwiseConv2DBackpropFilterD)

  108. DECLARE_OP_USE_INPUT_ATTR(DepthwiseConv2DBackpropFilterD)

  109. DECLARE_OP_USE_OUTPUT(DepthwiseConv2DBackpropFilterD)

  110. DECLARE_OP_ADAPTER(DepthwiseConv2DBackpropInputD)

  111. DECLARE_OP_USE_INPUT_ATTR(DepthwiseConv2DBackpropInputD)

  112. DECLARE_OP_USE_OUTPUT(DepthwiseConv2DBackpropInputD)

  113. DECLARE_OP_ADAPTER(Reshape)

  114. DECLARE_OP_USE_OUTPUT(Reshape)

  115. DECLARE_OP_ADAPTER(Iou)

  116. DECLARE_OP_USE_OUTPUT(Iou)

  117. DECLARE_OP_ADAPTER(ResizeNearestNeighborV2D)

  118. DECLARE_OP_USE_OUTPUT(ResizeNearestNeighborV2D)

  119. DECLARE_OP_ADAPTER(ResizeNearestNeighborV2Grad)

  120. DECLARE_OP_USE_OUTPUT(ResizeNearestNeighborV2Grad)

  121. DECLARE_OP_ADAPTER(ApplyAdam)

  122. DECLARE_OP_USE_OUTPUT(ApplyAdam)

  123. DECLARE_OP_ADAPTER(Relu6)

  124. DECLARE_OP_USE_OUTPUT(Relu6)

  125. DECLARE_OP_ADAPTER(Relu6Grad)

  126. DECLARE_OP_USE_OUTPUT(Relu6Grad)

  127. DECLARE_OP_ADAPTER(ResizeBilinearV2D)

  128. DECLARE_OP_USE_OUTPUT(ResizeBilinearV2D)

  129. DECLARE_OP_ADAPTER(ResizeBilinearV2Grad)

  130. DECLARE_OP_USE_OUTPUT(ResizeBilinearV2Grad)

  131. DECLARE_OP_ADAPTER(ZerosLike)

  132. DECLARE_OP_USE_OUTPUT(ZerosLike)

  133. DECLARE_OP_ADAPTER(OnesLike)

  134. DECLARE_OP_USE_OUTPUT(OnesLike)

  135. DECLARE_OP_ADAPTER(ScatterNdUpdate)

  136. DECLARE_OP_USE_OUTPUT(ScatterNdUpdate)

  137. DECLARE_OP_ADAPTER(ScatterMax)

  138. DECLARE_OP_USE_OUTPUT(ScatterMax)

  139. DECLARE_OP_ADAPTER(NMSWithMask)

  140. DECLARE_OP_USE_OUTPUT(NMSWithMask)

  141. DECLARE_OP_ADAPTER(Unpack)

  142. DECLARE_OP_USE_DYN_OUTPUT(Unpack)

  143. DECLARE_OP_ADAPTER(CheckValid)

  144. DECLARE_OP_USE_OUTPUT(CheckValid)

  145. DECLARE_OP_ADAPTER(SmoothL1Loss)

  146. DECLARE_OP_USE_OUTPUT(SmoothL1Loss)

  147. DECLARE_OP_ADAPTER(SmoothL1LossGrad)

  148. DECLARE_OP_USE_OUTPUT(SmoothL1LossGrad)

  149. DECLARE_OP_ADAPTER(SigmoidCrossEntropyWithLogits)

  150. DECLARE_OP_USE_OUTPUT(SigmoidCrossEntropyWithLogits)

  151. DECLARE_OP_ADAPTER(SigmoidCrossEntropyWithLogitsGrad)

  152. DECLARE_OP_USE_OUTPUT(SigmoidCrossEntropyWithLogitsGrad)

  153. DECLARE_OP_ADAPTER(ScatterNdD)

  154. DECLARE_OP_USE_INPUT_ATTR(ScatterNdD)

  155. DECLARE_OP_USE_OUTPUT(ScatterNdD)

  156. DECLARE_OP_ADAPTER(PadD)

  157. DECLARE_OP_USE_OUTPUT(PadD)

  158. DECLARE_OP_ADAPTER(MirrorPad)

  159. DECLARE_OP_USE_OUTPUT(MirrorPad)

  160. DECLARE_OP_ADAPTER(MirrorPadGrad)

  161. DECLARE_OP_USE_OUTPUT(MirrorPadGrad)

  162. DECLARE_OP_ADAPTER(BoundingBoxEncode)

  163. DECLARE_OP_USE_OUTPUT(BoundingBoxEncode)

  164. DECLARE_OP_ADAPTER(BoundingBoxDecode)

  165. DECLARE_OP_USE_OUTPUT(BoundingBoxDecode)

  166. DECLARE_OP_ADAPTER(GatherNd)

  167. DECLARE_OP_USE_OUTPUT(GatherNd)

  168. DECLARE_OP_ADAPTER(ArgMaxD)

  169. DECLARE_OP_USE_OUTPUT(ArgMaxD)

  170. DECLARE_OP_ADAPTER(ArgMinD)

  171. DECLARE_OP_USE_OUTPUT(ArgMinD)

  172. DECLARE_OP_ADAPTER(ArgMaxWithValue)

  173. DECLARE_OP_USE_OUTPUT(ArgMaxWithValue)

  174. DECLARE_OP_ADAPTER(ArgMinWithValue)

  175. DECLARE_OP_USE_OUTPUT(ArgMinWithValue)

  176. DECLARE_OP_ADAPTER(Mul)

  177. DECLARE_OP_USE_OUTPUT(Mul)

  178. DECLARE_OP_ADAPTER(AddN)

  179. DECLARE_OP_USE_DYN_INPUT(AddN)

  180. DECLARE_OP_USE_OUTPUT(AddN)

  181. DECLARE_OP_ADAPTER(Less)

  182. DECLARE_OP_USE_OUTPUT(Less)

  183. DECLARE_OP_ADAPTER(Rsqrt)

  184. DECLARE_OP_USE_OUTPUT(Rsqrt)

  185. DECLARE_OP_ADAPTER(Sqrt)

  186. DECLARE_OP_USE_OUTPUT(Sqrt)

  187. DECLARE_OP_ADAPTER(Square)

  188. DECLARE_OP_USE_OUTPUT(Square)

  189. DECLARE_OP_ADAPTER(SplitD)

  190. DECLARE_OP_USE_DYN_OUTPUT(SplitD)

  191. DECLARE_OP_ADAPTER(SGD)

  192. DECLARE_OP_USE_OUTPUT(SGD)

  193. DECLARE_OP_ADAPTER(SquareSumAll)

  194. DECLARE_OP_USE_OUTPUT(SquareSumAll)

  195. 

  196. DECLARE_OP_ADAPTER(Tanh)

  197. DECLARE_OP_USE_OUTPUT(Tanh)

  198. DECLARE_OP_ADAPTER(TanhGrad)

  199. DECLARE_OP_USE_OUTPUT(TanhGrad)

  200. DECLARE_OP_ADAPTER(Maximum)

  201. DECLARE_OP_USE_OUTPUT(Maximum)

  202. DECLARE_OP_ADAPTER(Minimum)

  203. DECLARE_OP_USE_OUTPUT(Minimum)

  204. DECLARE_OP_ADAPTER(MaximumGrad)

  205. DECLARE_OP_USE_OUTPUT(MaximumGrad)

  206. DECLARE_OP_ADAPTER(MinimumGrad)

  207. DECLARE_OP_USE_OUTPUT(MinimumGrad)

  208. DECLARE_OP_ADAPTER(ReduceMinD)

  209. DECLARE_OP_USE_INPUT_ATTR(ReduceMinD)

  210. DECLARE_OP_USE_OUTPUT(ReduceMinD)

  211. DECLARE_OP_ADAPTER(ReduceMaxD)

  212. DECLARE_OP_USE_INPUT_ATTR(ReduceMaxD)

  213. DECLARE_OP_USE_OUTPUT(ReduceMaxD)

  214. DECLARE_OP_ADAPTER(Merge)

  215. DECLARE_OP_USE_DYN_INPUT(Merge)

  216. DECLARE_OP_USE_OUTPUT(Merge)

  217. DECLARE_OP_ADAPTER(Switch)

  218. DECLARE_OP_USE_OUTPUT(Switch)

  219. 

  220. DECLARE_OP_ADAPTER(TopK)

  221. DECLARE_OP_USE_OUTPUT(TopK)

  222. 

  223. DECLARE_OP_ADAPTER(RealDiv)

  224. DECLARE_OP_USE_OUTPUT(RealDiv)

  225. 

  226. DECLARE_OP_ADAPTER(Cast)

  227. DECLARE_OP_USE_INPUT_ATTR(Cast)

  228. DECLARE_OP_USE_OUTPUT(Cast)

  229. DECLARE_OP_ADAPTER(Reciprocal)

  230. DECLARE_OP_USE_OUTPUT(Reciprocal)

  231. DECLARE_OP_ADAPTER(Neg)

  232. DECLARE_OP_USE_OUTPUT(Neg)

  233. DECLARE_OP_ADAPTER(TransposeD)

  234. DECLARE_OP_USE_INPUT_ATTR(TransposeD)

  235. // Do not set Transpose operator output descriptor

  236. DECLARE_OP_ADAPTER(Sub)

  237. DECLARE_OP_USE_OUTPUT(Sub)

  238. DECLARE_OP_ADAPTER(DropOutGenMask)

  239. DECLARE_OP_USE_OUTPUT(DropOutGenMask)

  240. DECLARE_OP_ADAPTER(ConcatD)

  241. DECLARE_OP_USE_DYN_INPUT(ConcatD)

  242. DECLARE_OP_USE_OUTPUT(ConcatD)

  243. DECLARE_OP_ADAPTER(Pack)

  244. DECLARE_OP_USE_DYN_INPUT(Pack)

  245. DECLARE_OP_USE_OUTPUT(Pack)

  246. 

  247. DECLARE_OP_ADAPTER(Pow)

  248. DECLARE_OP_USE_OUTPUT(Pow)

  249. DECLARE_OP_ADAPTER(Equal)

  250. DECLARE_OP_USE_OUTPUT(Equal)

  251. DECLARE_OP_ADAPTER(NotEqual)

  252. DECLARE_OP_USE_OUTPUT(NotEqual)

  253. DECLARE_OP_ADAPTER(Log)

  254. DECLARE_OP_USE_OUTPUT(Log)

  255. DECLARE_OP_ADAPTER(LogicalAnd)

  256. DECLARE_OP_USE_OUTPUT(LogicalAnd)

  257. DECLARE_OP_ADAPTER(LogicalOr)

  258. DECLARE_OP_USE_OUTPUT(LogicalOr)

  259. DECLARE_OP_ADAPTER(LogicalNot)

  260. DECLARE_OP_USE_OUTPUT(LogicalNot)

  261. DECLARE_OP_ADAPTER(LogSoftmaxGrad)

  262. DECLARE_OP_USE_OUTPUT(LogSoftmaxGrad)

  263. 

  264. DECLARE_OP_ADAPTER(RandomChoiceWithMask)

  265. DECLARE_OP_USE_OUTPUT(RandomChoiceWithMask)

  266. 

  267. DECLARE_OP_ADAPTER(Select)

  268. DECLARE_OP_USE_OUTPUT(Select)

  269. DECLARE_OP_ADAPTER(LessEqual)

  270. DECLARE_OP_USE_OUTPUT(LessEqual)

  271. DECLARE_OP_ADAPTER(LogSoftmaxV2)

  272. DECLARE_OP_USE_OUTPUT(LogSoftmaxV2)

  273. DECLARE_OP_ADAPTER(TruncatedNormal)

  274. DECLARE_OP_USE_OUTPUT(TruncatedNormal)

  275. DECLARE_OP_ADAPTER(StridedSliceGrad)

  276. DECLARE_OP_USE_OUTPUT(StridedSliceGrad)

  277. DECLARE_OP_ADAPTER(Gelu)

  278. DECLARE_OP_USE_OUTPUT(Gelu)

  279. DECLARE_OP_ADAPTER(GeluGrad)

  280. DECLARE_OP_USE_OUTPUT(GeluGrad)

  281. DECLARE_OP_ADAPTER(StridedSlice)

  282. DECLARE_OP_USE_OUTPUT(StridedSlice)

  283. DECLARE_OP_ADAPTER(UnsortedSegmentSumD)

  284. DECLARE_OP_USE_INPUT_ATTR(UnsortedSegmentSumD)

  285. DECLARE_OP_USE_OUTPUT(UnsortedSegmentSumD)

  286. DECLARE_OP_ADAPTER(ExpandDims)

  287. DECLARE_OP_USE_OUTPUT(ExpandDims)

  288. DECLARE_OP_ADAPTER(Squeeze)

  289. DECLARE_OP_USE_OUTPUT(Squeeze)

  290. DECLARE_OP_ADAPTER(LayerNorm)

  291. DECLARE_OP_USE_OUTPUT(LayerNorm)

  292. DECLARE_OP_ADAPTER(LayerNormGrad)

  293. DECLARE_OP_USE_OUTPUT(LayerNormGrad)

  294. DECLARE_OP_ADAPTER(BatchMatMul)

  295. DECLARE_OP_USE_OUTPUT(BatchMatMul)

  296. DECLARE_OP_ADAPTER(DropOutDoMask)

  297. DECLARE_OP_USE_OUTPUT(DropOutDoMask)

  298. // ** Mix-precision Operations **

  299. DECLARE_OP_ADAPTER(NPUGetFloatStatus)

  300. DECLARE_OP_USE_OUTPUT(NPUGetFloatStatus)

  301. DECLARE_OP_ADAPTER(NPUAllocFloatStatus)

  302. DECLARE_OP_USE_OUTPUT(NPUAllocFloatStatus)

  303. DECLARE_OP_ADAPTER(NPUClearFloatStatus)

  304. DECLARE_OP_USE_OUTPUT(NPUClearFloatStatus)

  305. DECLARE_OP_ADAPTER(MatMul)

  306. DECLARE_OP_USE_OUTPUT(MatMul)

  307. 

  308. DECLARE_OP_ADAPTER(SoftmaxCrossEntropyWithLogits)

  309. DECLARE_OP_USE_OUTPUT(SoftmaxCrossEntropyWithLogits)

  310. 

  311. DECLARE_OP_ADAPTER(MeanGrad)

  312. DECLARE_OP_USE_INPUT_ATTR(MeanGrad)

  313. 

  314. DECLARE_OP_ADAPTER(Assign)

  315. DECLARE_OP_USE_OUTPUT(Assign)

  316. DECLARE_OP_ADAPTER(Constant)

  317. DECLARE_OP_USE_OUTPUT(Constant)

  318. DECLARE_OP_ADAPTER(ApplyMomentum)

  319. DECLARE_OP_USE_OUTPUT(ApplyMomentum)

  320. // ** Summary Operations **

  321. DECLARE_OP_ADAPTER(Summary)

  322. 

  323. // fully supported

  324. DECLARE_OP_ADAPTER(Add)

  325. DECLARE_OP_USE_OUTPUT(Add)

  326. DECLARE_OP_ADAPTER(Const)

  327. DECLARE_OP_USE_OUTPUT(Const)

  328. DECLARE_OP_ADAPTER(Cos)

  329. DECLARE_OP_USE_OUTPUT(Cos)

  330. 

  331. DECLARE_OP_ADAPTER(Acos)

  332. DECLARE_OP_USE_OUTPUT(Acos)

  333. DECLARE_OP_ADAPTER(AcosGrad)

  334. DECLARE_OP_USE_OUTPUT(AcosGrad)

  335. DECLARE_OP_ADAPTER(Acosh)

  336. DECLARE_OP_USE_OUTPUT(Acosh)

  337. DECLARE_OP_ADAPTER(AcoshGrad)

  338. DECLARE_OP_USE_OUTPUT(AcoshGrad)

  339. 

  340. DECLARE_OP_ADAPTER(Floor)

  341. DECLARE_OP_USE_OUTPUT(Floor)

  342. DECLARE_OP_ADAPTER(FloorDiv)

  343. DECLARE_OP_USE_OUTPUT(FloorDiv)

  344. DECLARE_OP_ADAPTER(FloorMod)

  345. DECLARE_OP_USE_OUTPUT(FloorMod)

  346. DECLARE_OP_ADAPTER(Sin)

  347. DECLARE_OP_USE_OUTPUT(Sin)

  348. DECLARE_OP_ADAPTER(Exp)

  349. DECLARE_OP_USE_OUTPUT(Exp)

  350. 

  351. DECLARE_OP_ADAPTER(ReduceAllD)

  352. DECLARE_OP_USE_INPUT_ATTR(ReduceAllD)

  353. DECLARE_OP_USE_OUTPUT(ReduceAllD)

  354. DECLARE_OP_ADAPTER(ReduceSumD)

  355. DECLARE_OP_USE_INPUT_ATTR(ReduceSumD)

  356. DECLARE_OP_USE_OUTPUT(ReduceSumD)

  357. DECLARE_OP_ADAPTER(ReduceMeanD)

  358. DECLARE_OP_USE_INPUT_ATTR(ReduceMeanD)

  359. DECLARE_OP_USE_OUTPUT(ReduceMeanD)

  360. DECLARE_OP_ADAPTER(ReduceProdD)

  361. DECLARE_OP_USE_INPUT_ATTR(ReduceProdD)

  362. DECLARE_OP_USE_OUTPUT(ReduceProdD)

  363. DECLARE_OP_ADAPTER(CumprodD)

  364. DECLARE_OP_USE_INPUT_ATTR(CumprodD)

  365. DECLARE_OP_USE_OUTPUT(CumprodD)

  366. 

  367. DECLARE_OP_ADAPTER(TileD)

  368. DECLARE_OP_USE_INPUT_ATTR(TileD)

  369. DECLARE_OP_USE_OUTPUT(TileD)

  370. DECLARE_OP_ADAPTER(OneHot)

  371. DECLARE_OP_USE_OUTPUT(OneHot)

  372. DECLARE_OP_ADAPTER(GatherV2D)

  373. DECLARE_OP_USE_INPUT_ATTR(GatherV2D)

  374. DECLARE_OP_USE_OUTPUT(GatherV2D)

  375. 

  376. DECLARE_OP_ADAPTER(Data)

  377. DECLARE_OP_ADAPTER(BiasAdd)

  378. DECLARE_OP_USE_OUTPUT(BiasAdd)

  379. DECLARE_OP_ADAPTER(BatchNorm)

  380. DECLARE_OP_USE_OUTPUT(BatchNorm)

  381. DECLARE_OP_ADAPTER(BatchNormGrad)

  382. DECLARE_OP_USE_OUTPUT(BatchNormGrad)

  383. DECLARE_OP_ADAPTER(Relu)

  384. DECLARE_OP_USE_OUTPUT(Relu)

  385. DECLARE_OP_ADAPTER(PRelu)

  386. DECLARE_OP_USE_OUTPUT(PRelu)

  387. DECLARE_OP_ADAPTER(Elu)

  388. DECLARE_OP_USE_OUTPUT(Elu)

  389. 

  390. DECLARE_OP_ADAPTER(EluGrad)

  391. DECLARE_OP_USE_OUTPUT(EluGrad)

  392. DECLARE_OP_ADAPTER(PReluGrad)

  393. DECLARE_OP_USE_OUTPUT(PReluGrad)

  394. 

  395. DECLARE_OP_ADAPTER(L2Normalize)

  396. DECLARE_OP_USE_OUTPUT(L2Normalize)

  397. 

  398. DECLARE_OP_ADAPTER(CumsumD)

  399. DECLARE_OP_USE_INPUT_ATTR(CumsumD)

  400. DECLARE_OP_USE_OUTPUT(CumsumD)

  401. DECLARE_OP_ADAPTER(L2NormalizeGrad)

  402. DECLARE_OP_USE_OUTPUT(L2NormalizeGrad)

  403. DECLARE_OP_ADAPTER(Sigmoid)

  404. DECLARE_OP_USE_OUTPUT(Sigmoid)

  405. DECLARE_OP_ADAPTER(SigmoidGrad)

  406. DECLARE_OP_USE_OUTPUT(SigmoidGrad)

  407. DECLARE_OP_ADAPTER(SoftmaxV2)

  408. DECLARE_OP_USE_OUTPUT(SoftmaxV2)

  409. DECLARE_OP_ADAPTER(SoftmaxGrad)

  410. DECLARE_OP_USE_OUTPUT(SoftmaxGrad)

  411. DECLARE_OP_ADAPTER(Greater)

  412. DECLARE_OP_USE_OUTPUT(Greater)

  413. DECLARE_OP_ADAPTER(Flatten)

  414. DECLARE_OP_USE_OUTPUT(Flatten)

  415. DECLARE_OP_ADAPTER(GatherV2)

  416. DECLARE_OP_USE_OUTPUT(GatherV2)

  417. DECLARE_OP_ADAPTER(MaxPool)

  418. DECLARE_OP_USE_OUTPUT(MaxPool)

  419. DECLARE_OP_ADAPTER(MaxPoolGrad)

  420. DECLARE_OP_USE_OUTPUT(MaxPoolGrad)

  421. DECLARE_OP_ADAPTER(AvgPool)

  422. DECLARE_OP_USE_OUTPUT(AvgPool)

  423. DECLARE_OP_ADAPTER(AvgPoolGrad)

  424. DECLARE_OP_USE_OUTPUT(AvgPoolGrad)

  425. DECLARE_OP_ADAPTER(ROIAlign)

  426. DECLARE_OP_USE_OUTPUT(ROIAlign)

  427. DECLARE_OP_ADAPTER(ROIAlignGrad)

  428. DECLARE_OP_USE_OUTPUT(ROIAlignGrad)

  429. DECLARE_OP_ADAPTER(Abs)

  430. DECLARE_OP_USE_OUTPUT(Abs)

  431. DECLARE_OP_ADAPTER(AbsGrad)

  432. DECLARE_OP_USE_OUTPUT(AbsGrad)

  433. DECLARE_OP_ADAPTER(BinaryCrossEntropy)

  434. DECLARE_OP_USE_OUTPUT(BinaryCrossEntropy)

  435. DECLARE_OP_ADAPTER(BinaryCrossEntropyGrad)

  436. DECLARE_OP_USE_OUTPUT(BinaryCrossEntropyGrad)

  437. DECLARE_OP_ADAPTER(SparseApplyAdagradD)

  438. DECLARE_OP_USE_OUTPUT(SparseApplyAdagradD)

  439. DECLARE_OP_ADAPTER(SpaceToDepth)

  440. DECLARE_OP_USE_OUTPUT(SpaceToDepth)

  441. DECLARE_OP_ADAPTER(DepthToSpace)

  442. DECLARE_OP_USE_OUTPUT(DepthToSpace)

  443. DECLARE_OP_ADAPTER(Sign)

  444. DECLARE_OP_USE_OUTPUT(Sign)

  445. DECLARE_OP_ADAPTER(LarsV2Update)

  446. DECLARE_OP_USE_OUTPUT(LarsV2Update)

  447. DECLARE_OP_ADAPTER(Round)

  448. DECLARE_OP_USE_OUTPUT(Round)

  449. DECLARE_OP_ADAPTER(ApplyFtrl)

  450. DECLARE_OP_USE_OUTPUT(ApplyFtrl)

  451. DECLARE_OP_ADAPTER(SparseApplyFtrlD)

  452. DECLARE_OP_USE_OUTPUT(SparseApplyFtrlD)

  453. DECLARE_OP_ADAPTER(Diag)

  454. DECLARE_OP_USE_OUTPUT(Diag)

  455. DECLARE_OP_ADAPTER(DiagPart)

  456. DECLARE_OP_USE_OUTPUT(DiagPart)

  457. DECLARE_OP_ADAPTER(SpaceToBatchD)

  458. DECLARE_OP_USE_OUTPUT(SpaceToBatchD)

  459. DECLARE_OP_ADAPTER(BatchToSpaceD)

  460. DECLARE_OP_USE_OUTPUT(BatchToSpaceD)

  461. DECLARE_OP_ADAPTER(Atan2)

  462. DECLARE_OP_USE_OUTPUT(Atan2)

  463. DECLARE_OP_ADAPTER(ApplyRMSPropD)

  464. DECLARE_OP_USE_INPUT_ATTR(ApplyRMSPropD)

  465. DECLARE_OP_USE_OUTPUT(ApplyRMSPropD)

  466. DECLARE_OP_ADAPTER(ApplyCenteredRMSProp)

  467. DECLARE_OP_USE_OUTPUT(ApplyCenteredRMSProp)

  468. DECLARE_OP_ADAPTER(L2Loss)

  469. DECLARE_OP_USE_OUTPUT(L2Loss)

  470. DECLARE_OP_ADAPTER(CTCLoss)

  471. DECLARE_OP_USE_OUTPUT(CTCLoss)

  472. #ifdef ENABLE_GE

  473. DECLARE_OP_ADAPTER(Print)

  474. DECLARE_OP_USE_DYN_INPUT(Print)

  475. #endif

  476. }  // namespace transform

  477. }  // namespace mindspore

  478. #endif  // TRANSFORM_OP_DECLARE_H_