1 /**
2 * Copyright 2023 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 #include "ops/auto_generate/gen_lite_ops.h"
17 #include "mindapi/src/helper.h"
18 #include "ops/primitive_c.h"
19 #include "ops/base_operator.h"
20 #include "abstract/abstract_value.h"
21
22 namespace mindspore::ops {
23 REGISTER_PRIMITIVE_C(kNameACosGrad, ACosGrad);
24 MIND_API_OPERATOR_IMPL(ACosGrad, BaseOperator);
25
26 REGISTER_PRIMITIVE_C(kNameAbsGrad, AbsGrad);
27 MIND_API_OPERATOR_IMPL(AbsGrad, BaseOperator);
28
29 REGISTER_PRIMITIVE_C(kNameAbs, Abs);
30 MIND_API_OPERATOR_IMPL(Abs, BaseOperator);
31
32 REGISTER_PRIMITIVE_C(kNameACos, ACos);
33 MIND_API_OPERATOR_IMPL(ACos, BaseOperator);
34
35 REGISTER_PRIMITIVE_C(kNameAcoshGrad, AcoshGrad);
36 MIND_API_OPERATOR_IMPL(AcoshGrad, BaseOperator);
37
38 REGISTER_PRIMITIVE_C(kNameAcosh, Acosh);
39 MIND_API_OPERATOR_IMPL(Acosh, BaseOperator);
40
set_use_locking(const bool & use_locking)41 void AdamWeightDecay::set_use_locking(const bool &use_locking) { (void)this->AddAttr("use_locking", api::MakeValue(use_locking)); }
42
get_use_locking() const43 bool AdamWeightDecay::get_use_locking() const { return GetValue<bool>(GetAttr("use_locking")); }
44
45 REGISTER_PRIMITIVE_C(kNameAdamWeightDecay, AdamWeightDecay);
46 MIND_API_OPERATOR_IMPL(AdamWeightDecay, BaseOperator);
47
48 REGISTER_PRIMITIVE_C(kNameAdamW, AdamW);
49 MIND_API_OPERATOR_IMPL(AdamW, BaseOperator);
50
51 REGISTER_PRIMITIVE_C(kNameAddExt, AddExt);
52 MIND_API_OPERATOR_IMPL(AddExt, BaseOperator);
53
54 REGISTER_PRIMITIVE_C(kNameAddLayerNormV2, AddLayerNormV2);
55 MIND_API_OPERATOR_IMPL(AddLayerNormV2, BaseOperator);
56
57 REGISTER_PRIMITIVE_C(kNameAdd, Add);
58 MIND_API_OPERATOR_IMPL(Add, BaseOperator);
59
60 REGISTER_PRIMITIVE_C(kNameAddcdiv, Addcdiv);
61 MIND_API_OPERATOR_IMPL(Addcdiv, BaseOperator);
62
63 REGISTER_PRIMITIVE_C(kNameAddcmul, Addcmul);
64 MIND_API_OPERATOR_IMPL(Addcmul, BaseOperator);
65
66 REGISTER_PRIMITIVE_C(kNameAddmm, Addmm);
67 MIND_API_OPERATOR_IMPL(Addmm, BaseOperator);
68
69 REGISTER_PRIMITIVE_C(kNameAddN, AddN);
70 MIND_API_OPERATOR_IMPL(AddN, BaseOperator);
71
72 REGISTER_PRIMITIVE_C(kNameAngle, Angle);
73 MIND_API_OPERATOR_IMPL(Angle, BaseOperator);
74
75 REGISTER_PRIMITIVE_C(kNameApplyCamePart1, ApplyCamePart1);
76 MIND_API_OPERATOR_IMPL(ApplyCamePart1, BaseOperator);
77
78 REGISTER_PRIMITIVE_C(kNameApplyCamePart2, ApplyCamePart2);
79 MIND_API_OPERATOR_IMPL(ApplyCamePart2, BaseOperator);
80
81 REGISTER_PRIMITIVE_C(kNameApplyCamePart3, ApplyCamePart3);
82 MIND_API_OPERATOR_IMPL(ApplyCamePart3, BaseOperator);
83
84 REGISTER_PRIMITIVE_C(kNameApplyCamePart4, ApplyCamePart4);
85 MIND_API_OPERATOR_IMPL(ApplyCamePart4, BaseOperator);
86
set_cos_format(const int64_t & cos_format)87 void ApplyRotaryPosEmb::set_cos_format(const int64_t &cos_format) { (void)this->AddAttr("cos_format", api::MakeValue(cos_format)); }
88
get_cos_format() const89 int64_t ApplyRotaryPosEmb::get_cos_format() const { return GetValue<int64_t>(GetAttr("cos_format")); }
90
91 REGISTER_PRIMITIVE_C(kNameApplyRotaryPosEmb, ApplyRotaryPosEmb);
92 MIND_API_OPERATOR_IMPL(ApplyRotaryPosEmb, BaseOperator);
93
94 REGISTER_PRIMITIVE_C(kNameArange, Arange);
95 MIND_API_OPERATOR_IMPL(Arange, BaseOperator);
96
97 REGISTER_PRIMITIVE_C(kNameArgMaxExt, ArgMaxExt);
98 MIND_API_OPERATOR_IMPL(ArgMaxExt, BaseOperator);
99
set_axis(const int64_t & axis)100 void Argmax::set_axis(const int64_t &axis) { (void)this->AddAttr("axis", api::MakeValue(axis)); }
101
get_axis() const102 int64_t Argmax::get_axis() const { return GetValue<int64_t>(GetAttr("axis")); }
103
set_output_type(const int64_t & output_type)104 void Argmax::set_output_type(const int64_t &output_type) { (void)this->AddAttr("output_type", api::MakeValue(output_type)); }
105
get_output_type() const106 int64_t Argmax::get_output_type() const { return GetValue<int64_t>(GetAttr("output_type")); }
107
108 REGISTER_PRIMITIVE_C(kNameArgmax, Argmax);
109 MIND_API_OPERATOR_IMPL(Argmax, BaseOperator);
110
set_axis(const int64_t & axis)111 void ArgMaxWithValue::set_axis(const int64_t &axis) { (void)this->AddAttr("axis", api::MakeValue(axis)); }
112
get_axis() const113 int64_t ArgMaxWithValue::get_axis() const { return GetValue<int64_t>(GetAttr("axis")); }
114
set_keep_dims(const bool & keep_dims)115 void ArgMaxWithValue::set_keep_dims(const bool &keep_dims) { (void)this->AddAttr("keep_dims", api::MakeValue(keep_dims)); }
116
get_keep_dims() const117 bool ArgMaxWithValue::get_keep_dims() const { return GetValue<bool>(GetAttr("keep_dims")); }
118
119 REGISTER_PRIMITIVE_C(kNameArgMaxWithValue, ArgMaxWithValue);
120 MIND_API_OPERATOR_IMPL(ArgMaxWithValue, BaseOperator);
121
set_axis(const int64_t & axis)122 void Argmin::set_axis(const int64_t &axis) { (void)this->AddAttr("axis", api::MakeValue(axis)); }
123
get_axis() const124 int64_t Argmin::get_axis() const { return GetValue<int64_t>(GetAttr("axis")); }
125
set_output_type(const int64_t & output_type)126 void Argmin::set_output_type(const int64_t &output_type) { (void)this->AddAttr("output_type", api::MakeValue(output_type)); }
127
get_output_type() const128 int64_t Argmin::get_output_type() const { return GetValue<int64_t>(GetAttr("output_type")); }
129
130 REGISTER_PRIMITIVE_C(kNameArgmin, Argmin);
131 MIND_API_OPERATOR_IMPL(Argmin, BaseOperator);
132
set_axis(const int64_t & axis)133 void ArgMinWithValue::set_axis(const int64_t &axis) { (void)this->AddAttr("axis", api::MakeValue(axis)); }
134
get_axis() const135 int64_t ArgMinWithValue::get_axis() const { return GetValue<int64_t>(GetAttr("axis")); }
136
set_keep_dims(const bool & keep_dims)137 void ArgMinWithValue::set_keep_dims(const bool &keep_dims) { (void)this->AddAttr("keep_dims", api::MakeValue(keep_dims)); }
138
get_keep_dims() const139 bool ArgMinWithValue::get_keep_dims() const { return GetValue<bool>(GetAttr("keep_dims")); }
140
141 REGISTER_PRIMITIVE_C(kNameArgMinWithValue, ArgMinWithValue);
142 MIND_API_OPERATOR_IMPL(ArgMinWithValue, BaseOperator);
143
144 REGISTER_PRIMITIVE_C(kNameAsinGrad, AsinGrad);
145 MIND_API_OPERATOR_IMPL(AsinGrad, BaseOperator);
146
147 REGISTER_PRIMITIVE_C(kNameAsin, Asin);
148 MIND_API_OPERATOR_IMPL(Asin, BaseOperator);
149
150 REGISTER_PRIMITIVE_C(kNameAsinhGrad, AsinhGrad);
151 MIND_API_OPERATOR_IMPL(AsinhGrad, BaseOperator);
152
153 REGISTER_PRIMITIVE_C(kNameAsinh, Asinh);
154 MIND_API_OPERATOR_IMPL(Asinh, BaseOperator);
155
156 REGISTER_PRIMITIVE_C(kNameAssignAdd, AssignAdd);
157 MIND_API_OPERATOR_IMPL(AssignAdd, BaseOperator);
158
159 REGISTER_PRIMITIVE_C(kNameAssign, Assign);
160 MIND_API_OPERATOR_IMPL(Assign, BaseOperator);
161
162 REGISTER_PRIMITIVE_C(kNameAtan2Ext, Atan2Ext);
163 MIND_API_OPERATOR_IMPL(Atan2Ext, BaseOperator);
164
165 REGISTER_PRIMITIVE_C(kNameAtan2, Atan2);
166 MIND_API_OPERATOR_IMPL(Atan2, BaseOperator);
167
168 REGISTER_PRIMITIVE_C(kNameAtanGrad, AtanGrad);
169 MIND_API_OPERATOR_IMPL(AtanGrad, BaseOperator);
170
171 REGISTER_PRIMITIVE_C(kNameAtan, Atan);
172 MIND_API_OPERATOR_IMPL(Atan, BaseOperator);
173
174 REGISTER_PRIMITIVE_C(kNameAtanh, Atanh);
175 MIND_API_OPERATOR_IMPL(Atanh, BaseOperator);
176
177 REGISTER_PRIMITIVE_C(kNameAvgPool2DGrad, AvgPool2DGrad);
178 MIND_API_OPERATOR_IMPL(AvgPool2DGrad, BaseOperator);
179
180 REGISTER_PRIMITIVE_C(kNameAvgPool2D, AvgPool2D);
181 MIND_API_OPERATOR_IMPL(AvgPool2D, BaseOperator);
182
set_kernel_size(const std::vector<int64_t> & kernel_size)183 void AvgPoolGrad::set_kernel_size(const std::vector<int64_t> &kernel_size) { (void)this->AddAttr("kernel_size", api::MakeValue(kernel_size)); }
184
get_kernel_size() const185 std::vector<int64_t> AvgPoolGrad::get_kernel_size() const { return GetValue<std::vector<int64_t>>(GetAttr("kernel_size")); }
186
set_strides(const std::vector<int64_t> & strides)187 void AvgPoolGrad::set_strides(const std::vector<int64_t> &strides) { (void)this->AddAttr("strides", api::MakeValue(strides)); }
188
get_strides() const189 std::vector<int64_t> AvgPoolGrad::get_strides() const { return GetValue<std::vector<int64_t>>(GetAttr("strides")); }
190
set_pad_mode(const int64_t & pad_mode)191 void AvgPoolGrad::set_pad_mode(const int64_t &pad_mode) { (void)this->AddAttr("pad_mode", api::MakeValue(pad_mode)); }
192
get_pad_mode() const193 int64_t AvgPoolGrad::get_pad_mode() const { return GetValue<int64_t>(GetAttr("pad_mode")); }
194
set_data_format(const int64_t & data_format)195 void AvgPoolGrad::set_data_format(const int64_t &data_format) { (void)this->AddAttr("data_format", api::MakeValue(data_format)); }
196
get_data_format() const197 int64_t AvgPoolGrad::get_data_format() const { return GetValue<int64_t>(GetAttr("data_format")); }
198
199 REGISTER_PRIMITIVE_C(kNameAvgPoolGrad, AvgPoolGrad);
200 MIND_API_OPERATOR_IMPL(AvgPoolGrad, BaseOperator);
201
set_kernel_size(const std::vector<int64_t> & kernel_size)202 void AvgPool::set_kernel_size(const std::vector<int64_t> &kernel_size) { (void)this->AddAttr("kernel_size", api::MakeValue(kernel_size)); }
203
get_kernel_size() const204 std::vector<int64_t> AvgPool::get_kernel_size() const { return GetValue<std::vector<int64_t>>(GetAttr("kernel_size")); }
205
set_strides(const std::vector<int64_t> & strides)206 void AvgPool::set_strides(const std::vector<int64_t> &strides) { (void)this->AddAttr("strides", api::MakeValue(strides)); }
207
get_strides() const208 std::vector<int64_t> AvgPool::get_strides() const { return GetValue<std::vector<int64_t>>(GetAttr("strides")); }
209
set_pad_mode(const int64_t & pad_mode)210 void AvgPool::set_pad_mode(const int64_t &pad_mode) { (void)this->AddAttr("pad_mode", api::MakeValue(pad_mode)); }
211
get_pad_mode() const212 int64_t AvgPool::get_pad_mode() const { return GetValue<int64_t>(GetAttr("pad_mode")); }
213
set_data_format(const int64_t & data_format)214 void AvgPool::set_data_format(const int64_t &data_format) { (void)this->AddAttr("data_format", api::MakeValue(data_format)); }
215
get_data_format() const216 int64_t AvgPool::get_data_format() const { return GetValue<int64_t>(GetAttr("data_format")); }
217
218 REGISTER_PRIMITIVE_C(kNameAvgPool, AvgPool);
219 MIND_API_OPERATOR_IMPL(AvgPool, BaseOperator);
220
set_transpose_a(const bool & transpose_a)221 void BatchMatMul::set_transpose_a(const bool &transpose_a) { (void)this->AddAttr("transpose_a", api::MakeValue(transpose_a)); }
222
get_transpose_a() const223 bool BatchMatMul::get_transpose_a() const { return GetValue<bool>(GetAttr("transpose_a")); }
224
set_transpose_b(const bool & transpose_b)225 void BatchMatMul::set_transpose_b(const bool &transpose_b) { (void)this->AddAttr("transpose_b", api::MakeValue(transpose_b)); }
226
get_transpose_b() const227 bool BatchMatMul::get_transpose_b() const { return GetValue<bool>(GetAttr("transpose_b")); }
228
229 REGISTER_PRIMITIVE_C(kNameBatchMatMul, BatchMatMul);
230 MIND_API_OPERATOR_IMPL(BatchMatMul, BaseOperator);
231
232 REGISTER_PRIMITIVE_C(kNameBatchNormExt, BatchNormExt);
233 MIND_API_OPERATOR_IMPL(BatchNormExt, BaseOperator);
234
set_training(const bool & training)235 void BatchNormGradExt::set_training(const bool &training) { (void)this->AddAttr("training", api::MakeValue(training)); }
236
get_training() const237 bool BatchNormGradExt::get_training() const { return GetValue<bool>(GetAttr("training")); }
238
set_eps(const float & eps)239 void BatchNormGradExt::set_eps(const float &eps) { (void)this->AddAttr("eps", api::MakeValue(eps)); }
240
get_eps() const241 float BatchNormGradExt::get_eps() const { return GetValue<float>(GetAttr("eps")); }
242
243 REGISTER_PRIMITIVE_C(kNameBatchNormGradExt, BatchNormGradExt);
244 MIND_API_OPERATOR_IMPL(BatchNormGradExt, BaseOperator);
245
set_is_training(const bool & is_training)246 void BatchNormGradGrad::set_is_training(const bool &is_training) { (void)this->AddAttr("is_training", api::MakeValue(is_training)); }
247
get_is_training() const248 bool BatchNormGradGrad::get_is_training() const { return GetValue<bool>(GetAttr("is_training")); }
249
set_epsilon(const float & epsilon)250 void BatchNormGradGrad::set_epsilon(const float &epsilon) { (void)this->AddAttr("epsilon", api::MakeValue(epsilon)); }
251
get_epsilon() const252 float BatchNormGradGrad::get_epsilon() const { return GetValue<float>(GetAttr("epsilon")); }
253
set_data_format(const int64_t & data_format)254 void BatchNormGradGrad::set_data_format(const int64_t &data_format) { (void)this->AddAttr("data_format", api::MakeValue(data_format)); }
255
get_data_format() const256 int64_t BatchNormGradGrad::get_data_format() const { return GetValue<int64_t>(GetAttr("data_format")); }
257
258 REGISTER_PRIMITIVE_C(kNameBatchNormGradGrad, BatchNormGradGrad);
259 MIND_API_OPERATOR_IMPL(BatchNormGradGrad, BaseOperator);
260
set_is_training(const bool & is_training)261 void BatchNormGrad::set_is_training(const bool &is_training) { (void)this->AddAttr("is_training", api::MakeValue(is_training)); }
262
get_is_training() const263 bool BatchNormGrad::get_is_training() const { return GetValue<bool>(GetAttr("is_training")); }
264
set_epsilon(const float & epsilon)265 void BatchNormGrad::set_epsilon(const float &epsilon) { (void)this->AddAttr("epsilon", api::MakeValue(epsilon)); }
266
get_epsilon() const267 float BatchNormGrad::get_epsilon() const { return GetValue<float>(GetAttr("epsilon")); }
268
set_data_format(const int64_t & data_format)269 void BatchNormGrad::set_data_format(const int64_t &data_format) { (void)this->AddAttr("data_format", api::MakeValue(data_format)); }
270
get_data_format() const271 int64_t BatchNormGrad::get_data_format() const { return GetValue<int64_t>(GetAttr("data_format")); }
272
273 REGISTER_PRIMITIVE_C(kNameBatchNormGrad, BatchNormGrad);
274 MIND_API_OPERATOR_IMPL(BatchNormGrad, BaseOperator);
275
set_is_training(const bool & is_training)276 void BatchNormGradWithActivation::set_is_training(const bool &is_training) { (void)this->AddAttr("is_training", api::MakeValue(is_training)); }
277
get_is_training() const278 bool BatchNormGradWithActivation::get_is_training() const { return GetValue<bool>(GetAttr("is_training")); }
279
set_epsilon(const float & epsilon)280 void BatchNormGradWithActivation::set_epsilon(const float &epsilon) { (void)this->AddAttr("epsilon", api::MakeValue(epsilon)); }
281
get_epsilon() const282 float BatchNormGradWithActivation::get_epsilon() const { return GetValue<float>(GetAttr("epsilon")); }
283
set_data_format(const int64_t & data_format)284 void BatchNormGradWithActivation::set_data_format(const int64_t &data_format) { (void)this->AddAttr("data_format", api::MakeValue(data_format)); }
285
get_data_format() const286 int64_t BatchNormGradWithActivation::get_data_format() const { return GetValue<int64_t>(GetAttr("data_format")); }
287
288 REGISTER_PRIMITIVE_C(kNameBatchNormGradWithActivation, BatchNormGradWithActivation);
289 MIND_API_OPERATOR_IMPL(BatchNormGradWithActivation, BaseOperator);
290
set_is_training(const bool & is_training)291 void BatchNorm::set_is_training(const bool &is_training) { (void)this->AddAttr("is_training", api::MakeValue(is_training)); }
292
get_is_training() const293 bool BatchNorm::get_is_training() const { return GetValue<bool>(GetAttr("is_training")); }
294
set_epsilon(const float & epsilon)295 void BatchNorm::set_epsilon(const float &epsilon) { (void)this->AddAttr("epsilon", api::MakeValue(epsilon)); }
296
get_epsilon() const297 float BatchNorm::get_epsilon() const { return GetValue<float>(GetAttr("epsilon")); }
298
set_momentum(const float & momentum)299 void BatchNorm::set_momentum(const float &momentum) { (void)this->AddAttr("momentum", api::MakeValue(momentum)); }
300
get_momentum() const301 float BatchNorm::get_momentum() const { return GetValue<float>(GetAttr("momentum")); }
302
set_data_format(const int64_t & data_format)303 void BatchNorm::set_data_format(const int64_t &data_format) { (void)this->AddAttr("data_format", api::MakeValue(data_format)); }
304
get_data_format() const305 int64_t BatchNorm::get_data_format() const { return GetValue<int64_t>(GetAttr("data_format")); }
306
307 REGISTER_PRIMITIVE_C(kNameBatchNorm, BatchNorm);
308 MIND_API_OPERATOR_IMPL(BatchNorm, BaseOperator);
309
set_is_training(const bool & is_training)310 void BatchNormWithActivation::set_is_training(const bool &is_training) { (void)this->AddAttr("is_training", api::MakeValue(is_training)); }
311
get_is_training() const312 bool BatchNormWithActivation::get_is_training() const { return GetValue<bool>(GetAttr("is_training")); }
313
set_epsilon(const float & epsilon)314 void BatchNormWithActivation::set_epsilon(const float &epsilon) { (void)this->AddAttr("epsilon", api::MakeValue(epsilon)); }
315
get_epsilon() const316 float BatchNormWithActivation::get_epsilon() const { return GetValue<float>(GetAttr("epsilon")); }
317
set_momentum(const float & momentum)318 void BatchNormWithActivation::set_momentum(const float &momentum) { (void)this->AddAttr("momentum", api::MakeValue(momentum)); }
319
get_momentum() const320 float BatchNormWithActivation::get_momentum() const { return GetValue<float>(GetAttr("momentum")); }
321
set_data_format(const int64_t & data_format)322 void BatchNormWithActivation::set_data_format(const int64_t &data_format) { (void)this->AddAttr("data_format", api::MakeValue(data_format)); }
323
get_data_format() const324 int64_t BatchNormWithActivation::get_data_format() const { return GetValue<int64_t>(GetAttr("data_format")); }
325
326 REGISTER_PRIMITIVE_C(kNameBatchNormWithActivation, BatchNormWithActivation);
327 MIND_API_OPERATOR_IMPL(BatchNormWithActivation, BaseOperator);
328
set_is_training(const bool & is_training)329 void BatchNormWithAddAndActivation::set_is_training(const bool &is_training) { (void)this->AddAttr("is_training", api::MakeValue(is_training)); }
330
get_is_training() const331 bool BatchNormWithAddAndActivation::get_is_training() const { return GetValue<bool>(GetAttr("is_training")); }
332
set_epsilon(const float & epsilon)333 void BatchNormWithAddAndActivation::set_epsilon(const float &epsilon) { (void)this->AddAttr("epsilon", api::MakeValue(epsilon)); }
334
get_epsilon() const335 float BatchNormWithAddAndActivation::get_epsilon() const { return GetValue<float>(GetAttr("epsilon")); }
336
set_momentum(const float & momentum)337 void BatchNormWithAddAndActivation::set_momentum(const float &momentum) { (void)this->AddAttr("momentum", api::MakeValue(momentum)); }
338
get_momentum() const339 float BatchNormWithAddAndActivation::get_momentum() const { return GetValue<float>(GetAttr("momentum")); }
340
set_data_format(const int64_t & data_format)341 void BatchNormWithAddAndActivation::set_data_format(const int64_t &data_format) { (void)this->AddAttr("data_format", api::MakeValue(data_format)); }
342
get_data_format() const343 int64_t BatchNormWithAddAndActivation::get_data_format() const { return GetValue<int64_t>(GetAttr("data_format")); }
344
345 REGISTER_PRIMITIVE_C(kNameBatchNormWithAddAndActivation, BatchNormWithAddAndActivation);
346 MIND_API_OPERATOR_IMPL(BatchNormWithAddAndActivation, BaseOperator);
347
348 REGISTER_PRIMITIVE_C(kNameBetainc, Betainc);
349 MIND_API_OPERATOR_IMPL(Betainc, BaseOperator);
350
set_data_format(const int64_t & data_format)351 void BiasAddGrad::set_data_format(const int64_t &data_format) { (void)this->AddAttr("data_format", api::MakeValue(data_format)); }
352
get_data_format() const353 int64_t BiasAddGrad::get_data_format() const { return GetValue<int64_t>(GetAttr("data_format")); }
354
355 REGISTER_PRIMITIVE_C(kNameBiasAddGrad, BiasAddGrad);
356 MIND_API_OPERATOR_IMPL(BiasAddGrad, BaseOperator);
357
set_data_format(const int64_t & data_format)358 void BiasAdd::set_data_format(const int64_t &data_format) { (void)this->AddAttr("data_format", api::MakeValue(data_format)); }
359
get_data_format() const360 int64_t BiasAdd::get_data_format() const { return GetValue<int64_t>(GetAttr("data_format")); }
361
362 REGISTER_PRIMITIVE_C(kNameBiasAdd, BiasAdd);
363 MIND_API_OPERATOR_IMPL(BiasAdd, BaseOperator);
364
set_reduction(const int64_t & reduction)365 void BinaryCrossEntropyGrad::set_reduction(const int64_t &reduction) { (void)this->AddAttr("reduction", api::MakeValue(reduction)); }
366
get_reduction() const367 int64_t BinaryCrossEntropyGrad::get_reduction() const { return GetValue<int64_t>(GetAttr("reduction")); }
368
369 REGISTER_PRIMITIVE_C(kNameBinaryCrossEntropyGrad, BinaryCrossEntropyGrad);
370 MIND_API_OPERATOR_IMPL(BinaryCrossEntropyGrad, BaseOperator);
371
set_reduction(const int64_t & reduction)372 void BinaryCrossEntropy::set_reduction(const int64_t &reduction) { (void)this->AddAttr("reduction", api::MakeValue(reduction)); }
373
get_reduction() const374 int64_t BinaryCrossEntropy::get_reduction() const { return GetValue<int64_t>(GetAttr("reduction")); }
375
376 REGISTER_PRIMITIVE_C(kNameBinaryCrossEntropy, BinaryCrossEntropy);
377 MIND_API_OPERATOR_IMPL(BinaryCrossEntropy, BaseOperator);
378
379 REGISTER_PRIMITIVE_C(kNameBinaryCrossEntropyWithLogitsBackward, BinaryCrossEntropyWithLogitsBackward);
380 MIND_API_OPERATOR_IMPL(BinaryCrossEntropyWithLogitsBackward, BaseOperator);
381
set_reduction(const int64_t & reduction)382 void BCEWithLogitsLoss::set_reduction(const int64_t &reduction) { (void)this->AddAttr("reduction", api::MakeValue(reduction)); }
383
get_reduction() const384 int64_t BCEWithLogitsLoss::get_reduction() const { return GetValue<int64_t>(GetAttr("reduction")); }
385
386 REGISTER_PRIMITIVE_C(kNameBCEWithLogitsLoss, BCEWithLogitsLoss);
387 MIND_API_OPERATOR_IMPL(BCEWithLogitsLoss, BaseOperator);
388
389 REGISTER_PRIMITIVE_C(kNameBatchMatMulExt, BatchMatMulExt);
390 MIND_API_OPERATOR_IMPL(BatchMatMulExt, BaseOperator);
391
392 REGISTER_PRIMITIVE_C(kNameBoolNot, BoolNot);
393 MIND_API_OPERATOR_IMPL(BoolNot, BaseOperator);
394
set_shape(const std::vector<int64_t> & shape)395 void BroadcastTo::set_shape(const std::vector<int64_t> &shape) { (void)this->AddAttr("shape", api::MakeValue(shape)); }
396
get_shape() const397 std::vector<int64_t> BroadcastTo::get_shape() const { return GetValue<std::vector<int64_t>>(GetAttr("shape")); }
398
399 REGISTER_PRIMITIVE_C(kNameBroadcastTo, BroadcastTo);
400 MIND_API_OPERATOR_IMPL(BroadcastTo, BaseOperator);
401
402 REGISTER_PRIMITIVE_C(kNameCast, Cast);
403 MIND_API_OPERATOR_IMPL(Cast, BaseOperator);
404
405 REGISTER_PRIMITIVE_C(kNameCeil, Ceil);
406 MIND_API_OPERATOR_IMPL(Ceil, BaseOperator);
407
set_alpha(const float & alpha)408 void CeLU::set_alpha(const float &alpha) { (void)this->AddAttr("alpha", api::MakeValue(alpha)); }
409
get_alpha() const410 float CeLU::get_alpha() const { return GetValue<float>(GetAttr("alpha")); }
411
412 REGISTER_PRIMITIVE_C(kNameCeLU, CeLU);
413 MIND_API_OPERATOR_IMPL(CeLU, BaseOperator);
414
415 REGISTER_PRIMITIVE_C(kNameCholeskyGrad, CholeskyGrad);
416 MIND_API_OPERATOR_IMPL(CholeskyGrad, BaseOperator);
417
set_upper(const bool & upper)418 void CholeskyInverse::set_upper(const bool &upper) { (void)this->AddAttr("upper", api::MakeValue(upper)); }
419
get_upper() const420 bool CholeskyInverse::get_upper() const { return GetValue<bool>(GetAttr("upper")); }
421
422 REGISTER_PRIMITIVE_C(kNameCholeskyInverse, CholeskyInverse);
423 MIND_API_OPERATOR_IMPL(CholeskyInverse, BaseOperator);
424
set_upper(const bool & upper)425 void Cholesky::set_upper(const bool &upper) { (void)this->AddAttr("upper", api::MakeValue(upper)); }
426
get_upper() const427 bool Cholesky::get_upper() const { return GetValue<bool>(GetAttr("upper")); }
428
429 REGISTER_PRIMITIVE_C(kNameCholesky, Cholesky);
430 MIND_API_OPERATOR_IMPL(Cholesky, BaseOperator);
431
432 REGISTER_PRIMITIVE_C(kNameChunk, Chunk);
433 MIND_API_OPERATOR_IMPL(Chunk, BaseOperator);
434
435 REGISTER_PRIMITIVE_C(kNameClampScalar, ClampScalar);
436 MIND_API_OPERATOR_IMPL(ClampScalar, BaseOperator);
437
438 REGISTER_PRIMITIVE_C(kNameClampTensor, ClampTensor);
439 MIND_API_OPERATOR_IMPL(ClampTensor, BaseOperator);
440
441 REGISTER_PRIMITIVE_C(kNameCol2ImExt, Col2ImExt);
442 MIND_API_OPERATOR_IMPL(Col2ImExt, BaseOperator);
443
444 REGISTER_PRIMITIVE_C(kNameCol2ImGrad, Col2ImGrad);
445 MIND_API_OPERATOR_IMPL(Col2ImGrad, BaseOperator);
446
447 REGISTER_PRIMITIVE_C(kNameComplex, Complex);
448 MIND_API_OPERATOR_IMPL(Complex, BaseOperator);
449
set_axis(const int64_t & axis)450 void Concat::set_axis(const int64_t &axis) { (void)this->AddAttr("axis", api::MakeValue(axis)); }
451
get_axis() const452 int64_t Concat::get_axis() const { return GetValue<int64_t>(GetAttr("axis")); }
453
454 REGISTER_PRIMITIVE_C(kNameConcat, Concat);
455 MIND_API_OPERATOR_IMPL(Concat, BaseOperator);
456
457 REGISTER_PRIMITIVE_C(kNameConj, Conj);
458 MIND_API_OPERATOR_IMPL(Conj, BaseOperator);
459
460 REGISTER_PRIMITIVE_C(kNameConstantPadND, ConstantPadND);
461 MIND_API_OPERATOR_IMPL(ConstantPadND, BaseOperator);
462
463 REGISTER_PRIMITIVE_C(kNameContiguous, Contiguous);
464 MIND_API_OPERATOR_IMPL(Contiguous, BaseOperator);
465
set_stride(const std::vector<int64_t> & stride)466 void ConvolutionGrad::set_stride(const std::vector<int64_t> &stride) { (void)this->AddAttr("stride", api::MakeValue(stride)); }
467
get_stride() const468 std::vector<int64_t> ConvolutionGrad::get_stride() const { return GetValue<std::vector<int64_t>>(GetAttr("stride")); }
469
set_padding(const std::vector<int64_t> & padding)470 void ConvolutionGrad::set_padding(const std::vector<int64_t> &padding) { (void)this->AddAttr("padding", api::MakeValue(padding)); }
471
get_padding() const472 std::vector<int64_t> ConvolutionGrad::get_padding() const { return GetValue<std::vector<int64_t>>(GetAttr("padding")); }
473
set_dilation(const std::vector<int64_t> & dilation)474 void ConvolutionGrad::set_dilation(const std::vector<int64_t> &dilation) { (void)this->AddAttr("dilation", api::MakeValue(dilation)); }
475
get_dilation() const476 std::vector<int64_t> ConvolutionGrad::get_dilation() const { return GetValue<std::vector<int64_t>>(GetAttr("dilation")); }
477
set_transposed(const bool & transposed)478 void ConvolutionGrad::set_transposed(const bool &transposed) { (void)this->AddAttr("transposed", api::MakeValue(transposed)); }
479
get_transposed() const480 bool ConvolutionGrad::get_transposed() const { return GetValue<bool>(GetAttr("transposed")); }
481
set_output_padding(const std::vector<int64_t> & output_padding)482 void ConvolutionGrad::set_output_padding(const std::vector<int64_t> &output_padding) { (void)this->AddAttr("output_padding", api::MakeValue(output_padding)); }
483
get_output_padding() const484 std::vector<int64_t> ConvolutionGrad::get_output_padding() const { return GetValue<std::vector<int64_t>>(GetAttr("output_padding")); }
485
set_groups(const int64_t & groups)486 void ConvolutionGrad::set_groups(const int64_t &groups) { (void)this->AddAttr("groups", api::MakeValue(groups)); }
487
get_groups() const488 int64_t ConvolutionGrad::get_groups() const { return GetValue<int64_t>(GetAttr("groups")); }
489
set_output_mask(const std::vector<int64_t> & output_mask)490 void ConvolutionGrad::set_output_mask(const std::vector<int64_t> &output_mask) { (void)this->AddAttr("output_mask", api::MakeValue(output_mask)); }
491
get_output_mask() const492 std::vector<int64_t> ConvolutionGrad::get_output_mask() const { return GetValue<std::vector<int64_t>>(GetAttr("output_mask")); }
493
494 REGISTER_PRIMITIVE_C(kNameConvolutionGrad, ConvolutionGrad);
495 MIND_API_OPERATOR_IMPL(ConvolutionGrad, BaseOperator);
496
set_stride(const std::vector<int64_t> & stride)497 void Convolution::set_stride(const std::vector<int64_t> &stride) { (void)this->AddAttr("stride", api::MakeValue(stride)); }
498
get_stride() const499 std::vector<int64_t> Convolution::get_stride() const { return GetValue<std::vector<int64_t>>(GetAttr("stride")); }
500
set_padding(const std::vector<int64_t> & padding)501 void Convolution::set_padding(const std::vector<int64_t> &padding) { (void)this->AddAttr("padding", api::MakeValue(padding)); }
502
get_padding() const503 std::vector<int64_t> Convolution::get_padding() const { return GetValue<std::vector<int64_t>>(GetAttr("padding")); }
504
set_dilation(const std::vector<int64_t> & dilation)505 void Convolution::set_dilation(const std::vector<int64_t> &dilation) { (void)this->AddAttr("dilation", api::MakeValue(dilation)); }
506
get_dilation() const507 std::vector<int64_t> Convolution::get_dilation() const { return GetValue<std::vector<int64_t>>(GetAttr("dilation")); }
508
set_transposed(const bool & transposed)509 void Convolution::set_transposed(const bool &transposed) { (void)this->AddAttr("transposed", api::MakeValue(transposed)); }
510
get_transposed() const511 bool Convolution::get_transposed() const { return GetValue<bool>(GetAttr("transposed")); }
512
set_output_padding(const std::vector<int64_t> & output_padding)513 void Convolution::set_output_padding(const std::vector<int64_t> &output_padding) { (void)this->AddAttr("output_padding", api::MakeValue(output_padding)); }
514
get_output_padding() const515 std::vector<int64_t> Convolution::get_output_padding() const { return GetValue<std::vector<int64_t>>(GetAttr("output_padding")); }
516
set_groups(const int64_t & groups)517 void Convolution::set_groups(const int64_t &groups) { (void)this->AddAttr("groups", api::MakeValue(groups)); }
518
get_groups() const519 int64_t Convolution::get_groups() const { return GetValue<int64_t>(GetAttr("groups")); }
520
521 REGISTER_PRIMITIVE_C(kNameConvolution, Convolution);
522 MIND_API_OPERATOR_IMPL(Convolution, BaseOperator);
523
524 REGISTER_PRIMITIVE_C(kNameCopy, Copy);
525 MIND_API_OPERATOR_IMPL(Copy, BaseOperator);
526
set_mode(const int64_t & mode)527 void Correlate::set_mode(const int64_t &mode) { (void)this->AddAttr("mode", api::MakeValue(mode)); }
528
get_mode() const529 int64_t Correlate::get_mode() const { return GetValue<int64_t>(GetAttr("mode")); }
530
531 REGISTER_PRIMITIVE_C(kNameCorrelate, Correlate);
532 MIND_API_OPERATOR_IMPL(Correlate, BaseOperator);
533
534 REGISTER_PRIMITIVE_C(kNameCos, Cos);
535 MIND_API_OPERATOR_IMPL(Cos, BaseOperator);
536
537 REGISTER_PRIMITIVE_C(kNameCosh, Cosh);
538 MIND_API_OPERATOR_IMPL(Cosh, BaseOperator);
539
set_exclusive(const bool & exclusive)540 void CumProd::set_exclusive(const bool &exclusive) { (void)this->AddAttr("exclusive", api::MakeValue(exclusive)); }
541
get_exclusive() const542 bool CumProd::get_exclusive() const { return GetValue<bool>(GetAttr("exclusive")); }
543
set_reverse(const bool & reverse)544 void CumProd::set_reverse(const bool &reverse) { (void)this->AddAttr("reverse", api::MakeValue(reverse)); }
545
get_reverse() const546 bool CumProd::get_reverse() const { return GetValue<bool>(GetAttr("reverse")); }
547
548 REGISTER_PRIMITIVE_C(kNameCumProd, CumProd);
549 MIND_API_OPERATOR_IMPL(CumProd, BaseOperator);
550
set_exclusive(const bool & exclusive)551 void CumSum::set_exclusive(const bool &exclusive) { (void)this->AddAttr("exclusive", api::MakeValue(exclusive)); }
552
get_exclusive() const553 bool CumSum::get_exclusive() const { return GetValue<bool>(GetAttr("exclusive")); }
554
set_reverse(const bool & reverse)555 void CumSum::set_reverse(const bool &reverse) { (void)this->AddAttr("reverse", api::MakeValue(reverse)); }
556
get_reverse() const557 bool CumSum::get_reverse() const { return GetValue<bool>(GetAttr("reverse")); }
558
559 REGISTER_PRIMITIVE_C(kNameCumSum, CumSum);
560 MIND_API_OPERATOR_IMPL(CumSum, BaseOperator);
561
set_axis(const int64_t & axis)562 void Cummax::set_axis(const int64_t &axis) { (void)this->AddAttr("axis", api::MakeValue(axis)); }
563
get_axis() const564 int64_t Cummax::get_axis() const { return GetValue<int64_t>(GetAttr("axis")); }
565
566 REGISTER_PRIMITIVE_C(kNameCummax, Cummax);
567 MIND_API_OPERATOR_IMPL(Cummax, BaseOperator);
568
set_axis(const int64_t & axis)569 void Cummin::set_axis(const int64_t &axis) { (void)this->AddAttr("axis", api::MakeValue(axis)); }
570
get_axis() const571 int64_t Cummin::get_axis() const { return GetValue<int64_t>(GetAttr("axis")); }
572
573 REGISTER_PRIMITIVE_C(kNameCummin, Cummin);
574 MIND_API_OPERATOR_IMPL(Cummin, BaseOperator);
575
576 REGISTER_PRIMITIVE_C(kNameCumsumExt, CumsumExt);
577 MIND_API_OPERATOR_IMPL(CumsumExt, BaseOperator);
578
579 REGISTER_PRIMITIVE_C(kNameDCT, DCT);
580 MIND_API_OPERATOR_IMPL(DCT, BaseOperator);
581
582 REGISTER_PRIMITIVE_C(kNameDecoderKVCache, DecoderKVCache);
583 MIND_API_OPERATOR_IMPL(DecoderKVCache, BaseOperator);
584
585 REGISTER_PRIMITIVE_C(kNameDense, Dense);
586 MIND_API_OPERATOR_IMPL(Dense, BaseOperator);
587
588 REGISTER_PRIMITIVE_C(kNameDiag, Diag);
589 MIND_API_OPERATOR_IMPL(Diag, BaseOperator);
590
set_offset(const int64_t & offset)591 void Diagonal::set_offset(const int64_t &offset) { (void)this->AddAttr("offset", api::MakeValue(offset)); }
592
get_offset() const593 int64_t Diagonal::get_offset() const { return GetValue<int64_t>(GetAttr("offset")); }
594
set_dim1(const int64_t & dim1)595 void Diagonal::set_dim1(const int64_t &dim1) { (void)this->AddAttr("dim1", api::MakeValue(dim1)); }
596
get_dim1() const597 int64_t Diagonal::get_dim1() const { return GetValue<int64_t>(GetAttr("dim1")); }
598
set_dim2(const int64_t & dim2)599 void Diagonal::set_dim2(const int64_t &dim2) { (void)this->AddAttr("dim2", api::MakeValue(dim2)); }
600
get_dim2() const601 int64_t Diagonal::get_dim2() const { return GetValue<int64_t>(GetAttr("dim2")); }
602
603 REGISTER_PRIMITIVE_C(kNameDiagonal, Diagonal);
604 MIND_API_OPERATOR_IMPL(Diagonal, BaseOperator);
605
606 REGISTER_PRIMITIVE_C(kNameDiv, Div);
607 MIND_API_OPERATOR_IMPL(Div, BaseOperator);
608
609 REGISTER_PRIMITIVE_C(kNameDivMod, DivMod);
610 MIND_API_OPERATOR_IMPL(DivMod, BaseOperator);
611
612 REGISTER_PRIMITIVE_C(kNameDot, Dot);
613 MIND_API_OPERATOR_IMPL(Dot, BaseOperator);
614
615 REGISTER_PRIMITIVE_C(kNameDropoutDoMaskExt, DropoutDoMaskExt);
616 MIND_API_OPERATOR_IMPL(DropoutDoMaskExt, BaseOperator);
617
618 REGISTER_PRIMITIVE_C(kNameDropoutExt, DropoutExt);
619 MIND_API_OPERATOR_IMPL(DropoutExt, BaseOperator);
620
621 REGISTER_PRIMITIVE_C(kNameDropoutGenMaskExt, DropoutGenMaskExt);
622 MIND_API_OPERATOR_IMPL(DropoutGenMaskExt, BaseOperator);
623
624 REGISTER_PRIMITIVE_C(kNameDropoutGradExt, DropoutGradExt);
625 MIND_API_OPERATOR_IMPL(DropoutGradExt, BaseOperator);
626
set_keep_prob(const float & keep_prob)627 void Dropout::set_keep_prob(const float &keep_prob) { (void)this->AddAttr("keep_prob", api::MakeValue(keep_prob)); }
628
get_keep_prob() const629 float Dropout::get_keep_prob() const { return GetValue<float>(GetAttr("keep_prob")); }
630
set_Seed0(const int64_t & Seed0)631 void Dropout::set_Seed0(const int64_t &Seed0) { (void)this->AddAttr("Seed0", api::MakeValue(Seed0)); }
632
get_Seed0() const633 int64_t Dropout::get_Seed0() const { return GetValue<int64_t>(GetAttr("Seed0")); }
634
set_Seed1(const int64_t & Seed1)635 void Dropout::set_Seed1(const int64_t &Seed1) { (void)this->AddAttr("Seed1", api::MakeValue(Seed1)); }
636
get_Seed1() const637 int64_t Dropout::get_Seed1() const { return GetValue<int64_t>(GetAttr("Seed1")); }
638
639 REGISTER_PRIMITIVE_C(kNameDropout, Dropout);
640 MIND_API_OPERATOR_IMPL(Dropout, BaseOperator);
641
set_compute_v(const bool & compute_v)642 void Eig::set_compute_v(const bool &compute_v) { (void)this->AddAttr("compute_v", api::MakeValue(compute_v)); }
643
get_compute_v() const644 bool Eig::get_compute_v() const { return GetValue<bool>(GetAttr("compute_v")); }
645
646 REGISTER_PRIMITIVE_C(kNameEig, Eig);
647 MIND_API_OPERATOR_IMPL(Eig, BaseOperator);
648
set_alpha(const float & alpha)649 void EluExt::set_alpha(const float &alpha) { (void)this->AddAttr("alpha", api::MakeValue(alpha)); }
650
get_alpha() const651 float EluExt::get_alpha() const { return GetValue<float>(GetAttr("alpha")); }
652
653 REGISTER_PRIMITIVE_C(kNameEluExt, EluExt);
654 MIND_API_OPERATOR_IMPL(EluExt, BaseOperator);
655
656 REGISTER_PRIMITIVE_C(kNameEluGradExt, EluGradExt);
657 MIND_API_OPERATOR_IMPL(EluGradExt, BaseOperator);
658
659 REGISTER_PRIMITIVE_C(kNameEluGrad, EluGrad);
660 MIND_API_OPERATOR_IMPL(EluGrad, BaseOperator);
661
set_alpha(const float & alpha)662 void Elu::set_alpha(const float &alpha) { (void)this->AddAttr("alpha", api::MakeValue(alpha)); }
663
get_alpha() const664 float Elu::get_alpha() const { return GetValue<float>(GetAttr("alpha")); }
665
666 REGISTER_PRIMITIVE_C(kNameElu, Elu);
667 MIND_API_OPERATOR_IMPL(Elu, BaseOperator);
668
669 REGISTER_PRIMITIVE_C(kNameEmbeddingDenseBackward, EmbeddingDenseBackward);
670 MIND_API_OPERATOR_IMPL(EmbeddingDenseBackward, BaseOperator);
671
672 REGISTER_PRIMITIVE_C(kNameEmbedding, Embedding);
673 MIND_API_OPERATOR_IMPL(Embedding, BaseOperator);
674
675 REGISTER_PRIMITIVE_C(kNameEqual, Equal);
676 MIND_API_OPERATOR_IMPL(Equal, BaseOperator);
677
678 REGISTER_PRIMITIVE_C(kNameErf, Erf);
679 MIND_API_OPERATOR_IMPL(Erf, BaseOperator);
680
681 REGISTER_PRIMITIVE_C(kNameErfc, Erfc);
682 MIND_API_OPERATOR_IMPL(Erfc, BaseOperator);
683
684 REGISTER_PRIMITIVE_C(kNameErfinv, Erfinv);
685 MIND_API_OPERATOR_IMPL(Erfinv, BaseOperator);
686
687 REGISTER_PRIMITIVE_C(kNameExp, Exp);
688 MIND_API_OPERATOR_IMPL(Exp, BaseOperator);
689
690 REGISTER_PRIMITIVE_C(kNameExpandDims, ExpandDims);
691 MIND_API_OPERATOR_IMPL(ExpandDims, BaseOperator);
692
693 REGISTER_PRIMITIVE_C(kNameExpm1, Expm1);
694 MIND_API_OPERATOR_IMPL(Expm1, BaseOperator);
695
set_ksizes(const std::vector<int64_t> & ksizes)696 void ExtractImagePatches::set_ksizes(const std::vector<int64_t> &ksizes) { (void)this->AddAttr("ksizes", api::MakeValue(ksizes)); }
697
get_ksizes() const698 std::vector<int64_t> ExtractImagePatches::get_ksizes() const { return GetValue<std::vector<int64_t>>(GetAttr("ksizes")); }
699
set_strides(const std::vector<int64_t> & strides)700 void ExtractImagePatches::set_strides(const std::vector<int64_t> &strides) { (void)this->AddAttr("strides", api::MakeValue(strides)); }
701
get_strides() const702 std::vector<int64_t> ExtractImagePatches::get_strides() const { return GetValue<std::vector<int64_t>>(GetAttr("strides")); }
703
set_rates(const std::vector<int64_t> & rates)704 void ExtractImagePatches::set_rates(const std::vector<int64_t> &rates) { (void)this->AddAttr("rates", api::MakeValue(rates)); }
705
get_rates() const706 std::vector<int64_t> ExtractImagePatches::get_rates() const { return GetValue<std::vector<int64_t>>(GetAttr("rates")); }
707
set_padding(const int64_t & padding)708 void ExtractImagePatches::set_padding(const int64_t &padding) { (void)this->AddAttr("padding", api::MakeValue(padding)); }
709
get_padding() const710 int64_t ExtractImagePatches::get_padding() const { return GetValue<int64_t>(GetAttr("padding")); }
711
712 REGISTER_PRIMITIVE_C(kNameExtractImagePatches, ExtractImagePatches);
713 MIND_API_OPERATOR_IMPL(ExtractImagePatches, BaseOperator);
714
715 REGISTER_PRIMITIVE_C(kNameEye, Eye);
716 MIND_API_OPERATOR_IMPL(Eye, BaseOperator);
717
718 REGISTER_PRIMITIVE_C(kNameFastGeLUGrad, FastGeLUGrad);
719 MIND_API_OPERATOR_IMPL(FastGeLUGrad, BaseOperator);
720
721 REGISTER_PRIMITIVE_C(kNameFastGeLU, FastGeLU);
722 MIND_API_OPERATOR_IMPL(FastGeLU, BaseOperator);
723
set_activation(const int64_t & activation)724 void FFNExt::set_activation(const int64_t &activation) { (void)this->AddAttr("activation", api::MakeValue(activation)); }
725
get_activation() const726 int64_t FFNExt::get_activation() const { return GetValue<int64_t>(GetAttr("activation")); }
727
set_inner_precise(const int64_t & inner_precise)728 void FFNExt::set_inner_precise(const int64_t &inner_precise) { (void)this->AddAttr("inner_precise", api::MakeValue(inner_precise)); }
729
get_inner_precise() const730 int64_t FFNExt::get_inner_precise() const { return GetValue<int64_t>(GetAttr("inner_precise")); }
731
732 REGISTER_PRIMITIVE_C(kNameFFNExt, FFNExt);
733 MIND_API_OPERATOR_IMPL(FFNExt, BaseOperator);
734
735 REGISTER_PRIMITIVE_C(kNameFFT2, FFT2);
736 MIND_API_OPERATOR_IMPL(FFT2, BaseOperator);
737
738 REGISTER_PRIMITIVE_C(kNameFFT, FFT);
739 MIND_API_OPERATOR_IMPL(FFT, BaseOperator);
740
741 REGISTER_PRIMITIVE_C(kNameFFTShapeCopy, FFTShapeCopy);
742 MIND_API_OPERATOR_IMPL(FFTShapeCopy, BaseOperator);
743
set_signal_ndim(const int64_t & signal_ndim)744 void FFTWithSize::set_signal_ndim(const int64_t &signal_ndim) { (void)this->AddAttr("signal_ndim", api::MakeValue(signal_ndim)); }
745
get_signal_ndim() const746 int64_t FFTWithSize::get_signal_ndim() const { return GetValue<int64_t>(GetAttr("signal_ndim")); }
747
set_inverse(const bool & inverse)748 void FFTWithSize::set_inverse(const bool &inverse) { (void)this->AddAttr("inverse", api::MakeValue(inverse)); }
749
get_inverse() const750 bool FFTWithSize::get_inverse() const { return GetValue<bool>(GetAttr("inverse")); }
751
set_real(const bool & real)752 void FFTWithSize::set_real(const bool &real) { (void)this->AddAttr("real", api::MakeValue(real)); }
753
get_real() const754 bool FFTWithSize::get_real() const { return GetValue<bool>(GetAttr("real")); }
755
set_norm(const int64_t & norm)756 void FFTWithSize::set_norm(const int64_t &norm) { (void)this->AddAttr("norm", api::MakeValue(norm)); }
757
get_norm() const758 int64_t FFTWithSize::get_norm() const { return GetValue<int64_t>(GetAttr("norm")); }
759
set_onesided(const bool & onesided)760 void FFTWithSize::set_onesided(const bool &onesided) { (void)this->AddAttr("onesided", api::MakeValue(onesided)); }
761
get_onesided() const762 bool FFTWithSize::get_onesided() const { return GetValue<bool>(GetAttr("onesided")); }
763
set_signal_sizes(const std::vector<int64_t> & signal_sizes)764 void FFTWithSize::set_signal_sizes(const std::vector<int64_t> &signal_sizes) { (void)this->AddAttr("signal_sizes", api::MakeValue(signal_sizes)); }
765
get_signal_sizes() const766 std::vector<int64_t> FFTWithSize::get_signal_sizes() const { return GetValue<std::vector<int64_t>>(GetAttr("signal_sizes")); }
767
768 REGISTER_PRIMITIVE_C(kNameFFTWithSize, FFTWithSize);
769 MIND_API_OPERATOR_IMPL(FFTWithSize, BaseOperator);
770
771 REGISTER_PRIMITIVE_C(kNameFFTN, FFTN);
772 MIND_API_OPERATOR_IMPL(FFTN, BaseOperator);
773
774 REGISTER_PRIMITIVE_C(kNameFFTShift, FFTShift);
775 MIND_API_OPERATOR_IMPL(FFTShift, BaseOperator);
776
777 REGISTER_PRIMITIVE_C(kNameFillScalar, FillScalar);
778 MIND_API_OPERATOR_IMPL(FillScalar, BaseOperator);
779
780 REGISTER_PRIMITIVE_C(kNameFillTensor, FillTensor);
781 MIND_API_OPERATOR_IMPL(FillTensor, BaseOperator);
782
set_head_num(const int64_t & head_num)783 void FlashAttentionScoreGrad::set_head_num(const int64_t &head_num) { (void)this->AddAttr("head_num", api::MakeValue(head_num)); }
784
get_head_num() const785 int64_t FlashAttentionScoreGrad::get_head_num() const { return GetValue<int64_t>(GetAttr("head_num")); }
786
set_keep_prob(const float & keep_prob)787 void FlashAttentionScoreGrad::set_keep_prob(const float &keep_prob) { (void)this->AddAttr("keep_prob", api::MakeValue(keep_prob)); }
788
get_keep_prob() const789 float FlashAttentionScoreGrad::get_keep_prob() const { return GetValue<float>(GetAttr("keep_prob")); }
790
set_scale_value(const float & scale_value)791 void FlashAttentionScoreGrad::set_scale_value(const float &scale_value) { (void)this->AddAttr("scale_value", api::MakeValue(scale_value)); }
792
get_scale_value() const793 float FlashAttentionScoreGrad::get_scale_value() const { return GetValue<float>(GetAttr("scale_value")); }
794
set_pre_tokens(const int64_t & pre_tokens)795 void FlashAttentionScoreGrad::set_pre_tokens(const int64_t &pre_tokens) { (void)this->AddAttr("pre_tokens", api::MakeValue(pre_tokens)); }
796
get_pre_tokens() const797 int64_t FlashAttentionScoreGrad::get_pre_tokens() const { return GetValue<int64_t>(GetAttr("pre_tokens")); }
798
set_next_tokens(const int64_t & next_tokens)799 void FlashAttentionScoreGrad::set_next_tokens(const int64_t &next_tokens) { (void)this->AddAttr("next_tokens", api::MakeValue(next_tokens)); }
800
get_next_tokens() const801 int64_t FlashAttentionScoreGrad::get_next_tokens() const { return GetValue<int64_t>(GetAttr("next_tokens")); }
802
set_inner_precise(const int64_t & inner_precise)803 void FlashAttentionScoreGrad::set_inner_precise(const int64_t &inner_precise) { (void)this->AddAttr("inner_precise", api::MakeValue(inner_precise)); }
804
get_inner_precise() const805 int64_t FlashAttentionScoreGrad::get_inner_precise() const { return GetValue<int64_t>(GetAttr("inner_precise")); }
806
set_input_layout(const int64_t & input_layout)807 void FlashAttentionScoreGrad::set_input_layout(const int64_t &input_layout) { (void)this->AddAttr("input_layout", api::MakeValue(input_layout)); }
808
get_input_layout() const809 int64_t FlashAttentionScoreGrad::get_input_layout() const { return GetValue<int64_t>(GetAttr("input_layout")); }
810
set_sparse_mode(const int64_t & sparse_mode)811 void FlashAttentionScoreGrad::set_sparse_mode(const int64_t &sparse_mode) { (void)this->AddAttr("sparse_mode", api::MakeValue(sparse_mode)); }
812
get_sparse_mode() const813 int64_t FlashAttentionScoreGrad::get_sparse_mode() const { return GetValue<int64_t>(GetAttr("sparse_mode")); }
814
815 REGISTER_PRIMITIVE_C(kNameFlashAttentionScoreGrad, FlashAttentionScoreGrad);
816 MIND_API_OPERATOR_IMPL(FlashAttentionScoreGrad, BaseOperator);
817
set_head_num(const int64_t & head_num)818 void FlashAttentionScore::set_head_num(const int64_t &head_num) { (void)this->AddAttr("head_num", api::MakeValue(head_num)); }
819
get_head_num() const820 int64_t FlashAttentionScore::get_head_num() const { return GetValue<int64_t>(GetAttr("head_num")); }
821
set_keep_prob(const float & keep_prob)822 void FlashAttentionScore::set_keep_prob(const float &keep_prob) { (void)this->AddAttr("keep_prob", api::MakeValue(keep_prob)); }
823
get_keep_prob() const824 float FlashAttentionScore::get_keep_prob() const { return GetValue<float>(GetAttr("keep_prob")); }
825
set_scale_value(const float & scale_value)826 void FlashAttentionScore::set_scale_value(const float &scale_value) { (void)this->AddAttr("scale_value", api::MakeValue(scale_value)); }
827
get_scale_value() const828 float FlashAttentionScore::get_scale_value() const { return GetValue<float>(GetAttr("scale_value")); }
829
set_pre_tokens(const int64_t & pre_tokens)830 void FlashAttentionScore::set_pre_tokens(const int64_t &pre_tokens) { (void)this->AddAttr("pre_tokens", api::MakeValue(pre_tokens)); }
831
get_pre_tokens() const832 int64_t FlashAttentionScore::get_pre_tokens() const { return GetValue<int64_t>(GetAttr("pre_tokens")); }
833
set_next_tokens(const int64_t & next_tokens)834 void FlashAttentionScore::set_next_tokens(const int64_t &next_tokens) { (void)this->AddAttr("next_tokens", api::MakeValue(next_tokens)); }
835
get_next_tokens() const836 int64_t FlashAttentionScore::get_next_tokens() const { return GetValue<int64_t>(GetAttr("next_tokens")); }
837
set_inner_precise(const int64_t & inner_precise)838 void FlashAttentionScore::set_inner_precise(const int64_t &inner_precise) { (void)this->AddAttr("inner_precise", api::MakeValue(inner_precise)); }
839
get_inner_precise() const840 int64_t FlashAttentionScore::get_inner_precise() const { return GetValue<int64_t>(GetAttr("inner_precise")); }
841
set_input_layout(const int64_t & input_layout)842 void FlashAttentionScore::set_input_layout(const int64_t &input_layout) { (void)this->AddAttr("input_layout", api::MakeValue(input_layout)); }
843
get_input_layout() const844 int64_t FlashAttentionScore::get_input_layout() const { return GetValue<int64_t>(GetAttr("input_layout")); }
845
set_sparse_mode(const int64_t & sparse_mode)846 void FlashAttentionScore::set_sparse_mode(const int64_t &sparse_mode) { (void)this->AddAttr("sparse_mode", api::MakeValue(sparse_mode)); }
847
get_sparse_mode() const848 int64_t FlashAttentionScore::get_sparse_mode() const { return GetValue<int64_t>(GetAttr("sparse_mode")); }
849
850 REGISTER_PRIMITIVE_C(kNameFlashAttentionScore, FlashAttentionScore);
851 MIND_API_OPERATOR_IMPL(FlashAttentionScore, BaseOperator);
852
853 REGISTER_PRIMITIVE_C(kNameFlattenExt, FlattenExt);
854 MIND_API_OPERATOR_IMPL(FlattenExt, BaseOperator);
855
856 REGISTER_PRIMITIVE_C(kNameFlatten, Flatten);
857 MIND_API_OPERATOR_IMPL(Flatten, BaseOperator);
858
859 REGISTER_PRIMITIVE_C(kNameFloorDiv, FloorDiv);
860 MIND_API_OPERATOR_IMPL(FloorDiv, BaseOperator);
861
862 REGISTER_PRIMITIVE_C(kNameFloorMod, FloorMod);
863 MIND_API_OPERATOR_IMPL(FloorMod, BaseOperator);
864
865 REGISTER_PRIMITIVE_C(kNameFloor, Floor);
866 MIND_API_OPERATOR_IMPL(Floor, BaseOperator);
867
868 REGISTER_PRIMITIVE_C(kNameGatherDGradV2, GatherDGradV2);
869 MIND_API_OPERATOR_IMPL(GatherDGradV2, BaseOperator);
870
871 REGISTER_PRIMITIVE_C(kNameGatherD, GatherD);
872 MIND_API_OPERATOR_IMPL(GatherD, BaseOperator);
873
874 REGISTER_PRIMITIVE_C(kNameGatherNd, GatherNd);
875 MIND_API_OPERATOR_IMPL(GatherNd, BaseOperator);
876
set_batch_dims(const int64_t & batch_dims)877 void Gather::set_batch_dims(const int64_t &batch_dims) { (void)this->AddAttr("batch_dims", api::MakeValue(batch_dims)); }
878
get_batch_dims() const879 int64_t Gather::get_batch_dims() const { return GetValue<int64_t>(GetAttr("batch_dims")); }
880
881 REGISTER_PRIMITIVE_C(kNameGather, Gather);
882 MIND_API_OPERATOR_IMPL(Gather, BaseOperator);
883
884 REGISTER_PRIMITIVE_C(kNameGcd, Gcd);
885 MIND_API_OPERATOR_IMPL(Gcd, BaseOperator);
886
887 REGISTER_PRIMITIVE_C(kNameGeLUGrad, GeLUGrad);
888 MIND_API_OPERATOR_IMPL(GeLUGrad, BaseOperator);
889
890 REGISTER_PRIMITIVE_C(kNameGeLU, GeLU);
891 MIND_API_OPERATOR_IMPL(GeLU, BaseOperator);
892
893 REGISTER_PRIMITIVE_C(kNameGenerator, Generator);
894 MIND_API_OPERATOR_IMPL(Generator, BaseOperator);
895
896 REGISTER_PRIMITIVE_C(kNameGeqrf, Geqrf);
897 MIND_API_OPERATOR_IMPL(Geqrf, BaseOperator);
898
899 REGISTER_PRIMITIVE_C(kNameGreaterEqual, GreaterEqual);
900 MIND_API_OPERATOR_IMPL(GreaterEqual, BaseOperator);
901
902 REGISTER_PRIMITIVE_C(kNameGreater, Greater);
903 MIND_API_OPERATOR_IMPL(Greater, BaseOperator);
904
set_interpolation_mode(const int64_t & interpolation_mode)905 void GridSampler2DGrad::set_interpolation_mode(const int64_t &interpolation_mode) { (void)this->AddAttr("interpolation_mode", api::MakeValue(interpolation_mode)); }
906
get_interpolation_mode() const907 int64_t GridSampler2DGrad::get_interpolation_mode() const { return GetValue<int64_t>(GetAttr("interpolation_mode")); }
908
set_padding_mode(const int64_t & padding_mode)909 void GridSampler2DGrad::set_padding_mode(const int64_t &padding_mode) { (void)this->AddAttr("padding_mode", api::MakeValue(padding_mode)); }
910
get_padding_mode() const911 int64_t GridSampler2DGrad::get_padding_mode() const { return GetValue<int64_t>(GetAttr("padding_mode")); }
912
set_align_corners(const bool & align_corners)913 void GridSampler2DGrad::set_align_corners(const bool &align_corners) { (void)this->AddAttr("align_corners", api::MakeValue(align_corners)); }
914
get_align_corners() const915 bool GridSampler2DGrad::get_align_corners() const { return GetValue<bool>(GetAttr("align_corners")); }
916
917 REGISTER_PRIMITIVE_C(kNameGridSampler2DGrad, GridSampler2DGrad);
918 MIND_API_OPERATOR_IMPL(GridSampler2DGrad, BaseOperator);
919
set_interpolation_mode(const int64_t & interpolation_mode)920 void GridSampler2D::set_interpolation_mode(const int64_t &interpolation_mode) { (void)this->AddAttr("interpolation_mode", api::MakeValue(interpolation_mode)); }
921
get_interpolation_mode() const922 int64_t GridSampler2D::get_interpolation_mode() const { return GetValue<int64_t>(GetAttr("interpolation_mode")); }
923
set_padding_mode(const int64_t & padding_mode)924 void GridSampler2D::set_padding_mode(const int64_t &padding_mode) { (void)this->AddAttr("padding_mode", api::MakeValue(padding_mode)); }
925
get_padding_mode() const926 int64_t GridSampler2D::get_padding_mode() const { return GetValue<int64_t>(GetAttr("padding_mode")); }
927
set_align_corners(const bool & align_corners)928 void GridSampler2D::set_align_corners(const bool &align_corners) { (void)this->AddAttr("align_corners", api::MakeValue(align_corners)); }
929
get_align_corners() const930 bool GridSampler2D::get_align_corners() const { return GetValue<bool>(GetAttr("align_corners")); }
931
932 REGISTER_PRIMITIVE_C(kNameGridSampler2D, GridSampler2D);
933 MIND_API_OPERATOR_IMPL(GridSampler2D, BaseOperator);
934
set_interpolation_mode(const int64_t & interpolation_mode)935 void GridSampler3DGrad::set_interpolation_mode(const int64_t &interpolation_mode) { (void)this->AddAttr("interpolation_mode", api::MakeValue(interpolation_mode)); }
936
get_interpolation_mode() const937 int64_t GridSampler3DGrad::get_interpolation_mode() const { return GetValue<int64_t>(GetAttr("interpolation_mode")); }
938
set_padding_mode(const int64_t & padding_mode)939 void GridSampler3DGrad::set_padding_mode(const int64_t &padding_mode) { (void)this->AddAttr("padding_mode", api::MakeValue(padding_mode)); }
940
get_padding_mode() const941 int64_t GridSampler3DGrad::get_padding_mode() const { return GetValue<int64_t>(GetAttr("padding_mode")); }
942
set_align_corners(const bool & align_corners)943 void GridSampler3DGrad::set_align_corners(const bool &align_corners) { (void)this->AddAttr("align_corners", api::MakeValue(align_corners)); }
944
get_align_corners() const945 bool GridSampler3DGrad::get_align_corners() const { return GetValue<bool>(GetAttr("align_corners")); }
946
947 REGISTER_PRIMITIVE_C(kNameGridSampler3DGrad, GridSampler3DGrad);
948 MIND_API_OPERATOR_IMPL(GridSampler3DGrad, BaseOperator);
949
set_interpolation_mode(const int64_t & interpolation_mode)950 void GridSampler3D::set_interpolation_mode(const int64_t &interpolation_mode) { (void)this->AddAttr("interpolation_mode", api::MakeValue(interpolation_mode)); }
951
get_interpolation_mode() const952 int64_t GridSampler3D::get_interpolation_mode() const { return GetValue<int64_t>(GetAttr("interpolation_mode")); }
953
set_padding_mode(const int64_t & padding_mode)954 void GridSampler3D::set_padding_mode(const int64_t &padding_mode) { (void)this->AddAttr("padding_mode", api::MakeValue(padding_mode)); }
955
get_padding_mode() const956 int64_t GridSampler3D::get_padding_mode() const { return GetValue<int64_t>(GetAttr("padding_mode")); }
957
set_align_corners(const bool & align_corners)958 void GridSampler3D::set_align_corners(const bool &align_corners) { (void)this->AddAttr("align_corners", api::MakeValue(align_corners)); }
959
get_align_corners() const960 bool GridSampler3D::get_align_corners() const { return GetValue<bool>(GetAttr("align_corners")); }
961
962 REGISTER_PRIMITIVE_C(kNameGridSampler3D, GridSampler3D);
963 MIND_API_OPERATOR_IMPL(GridSampler3D, BaseOperator);
964
965 REGISTER_PRIMITIVE_C(kNameGroupNormGrad, GroupNormGrad);
966 MIND_API_OPERATOR_IMPL(GroupNormGrad, BaseOperator);
967
968 REGISTER_PRIMITIVE_C(kNameGroupNorm, GroupNorm);
969 MIND_API_OPERATOR_IMPL(GroupNorm, BaseOperator);
970
set_lambd(const float & lambd)971 void HShrinkGrad::set_lambd(const float &lambd) { (void)this->AddAttr("lambd", api::MakeValue(lambd)); }
972
get_lambd() const973 float HShrinkGrad::get_lambd() const { return GetValue<float>(GetAttr("lambd")); }
974
975 REGISTER_PRIMITIVE_C(kNameHShrinkGrad, HShrinkGrad);
976 MIND_API_OPERATOR_IMPL(HShrinkGrad, BaseOperator);
977
set_lambd(const float & lambd)978 void HShrink::set_lambd(const float &lambd) { (void)this->AddAttr("lambd", api::MakeValue(lambd)); }
979
get_lambd() const980 float HShrink::get_lambd() const { return GetValue<float>(GetAttr("lambd")); }
981
982 REGISTER_PRIMITIVE_C(kNameHShrink, HShrink);
983 MIND_API_OPERATOR_IMPL(HShrink, BaseOperator);
984
985 REGISTER_PRIMITIVE_C(kNameHSigmoidGrad, HSigmoidGrad);
986 MIND_API_OPERATOR_IMPL(HSigmoidGrad, BaseOperator);
987
988 REGISTER_PRIMITIVE_C(kNameHSigmoid, HSigmoid);
989 MIND_API_OPERATOR_IMPL(HSigmoid, BaseOperator);
990
991 REGISTER_PRIMITIVE_C(kNameHSwishGrad, HSwishGrad);
992 MIND_API_OPERATOR_IMPL(HSwishGrad, BaseOperator);
993
994 REGISTER_PRIMITIVE_C(kNameHSwish, HSwish);
995 MIND_API_OPERATOR_IMPL(HSwish, BaseOperator);
996
997 REGISTER_PRIMITIVE_C(kNameIdentity, Identity);
998 MIND_API_OPERATOR_IMPL(Identity, BaseOperator);
999
1000 REGISTER_PRIMITIVE_C(kNameIFFT2, IFFT2);
1001 MIND_API_OPERATOR_IMPL(IFFT2, BaseOperator);
1002
1003 REGISTER_PRIMITIVE_C(kNameIFFT, IFFT);
1004 MIND_API_OPERATOR_IMPL(IFFT, BaseOperator);
1005
1006 REGISTER_PRIMITIVE_C(kNameIFFTN, IFFTN);
1007 MIND_API_OPERATOR_IMPL(IFFTN, BaseOperator);
1008
1009 REGISTER_PRIMITIVE_C(kNameIFFTShift, IFFTShift);
1010 MIND_API_OPERATOR_IMPL(IFFTShift, BaseOperator);
1011
1012 REGISTER_PRIMITIVE_C(kNameIm2ColExt, Im2ColExt);
1013 MIND_API_OPERATOR_IMPL(Im2ColExt, BaseOperator);
1014
1015 REGISTER_PRIMITIVE_C(kNameIndexAddExt, IndexAddExt);
1016 MIND_API_OPERATOR_IMPL(IndexAddExt, BaseOperator);
1017
1018 REGISTER_PRIMITIVE_C(kNameIndexSelect, IndexSelect);
1019 MIND_API_OPERATOR_IMPL(IndexSelect, BaseOperator);
1020
1021 REGISTER_PRIMITIVE_C(kNameIRFFTGrad, IRFFTGrad);
1022 MIND_API_OPERATOR_IMPL(IRFFTGrad, BaseOperator);
1023
1024 REGISTER_PRIMITIVE_C(kNameIRFFT, IRFFT);
1025 MIND_API_OPERATOR_IMPL(IRFFT, BaseOperator);
1026
set_rtol(const float & rtol)1027 void IsClose::set_rtol(const float &rtol) { (void)this->AddAttr("rtol", api::MakeValue(rtol)); }
1028
get_rtol() const1029 float IsClose::get_rtol() const { return GetValue<float>(GetAttr("rtol")); }
1030
set_atol(const float & atol)1031 void IsClose::set_atol(const float &atol) { (void)this->AddAttr("atol", api::MakeValue(atol)); }
1032
get_atol() const1033 float IsClose::get_atol() const { return GetValue<float>(GetAttr("atol")); }
1034
set_equal_nan(const bool & equal_nan)1035 void IsClose::set_equal_nan(const bool &equal_nan) { (void)this->AddAttr("equal_nan", api::MakeValue(equal_nan)); }
1036
get_equal_nan() const1037 bool IsClose::get_equal_nan() const { return GetValue<bool>(GetAttr("equal_nan")); }
1038
1039 REGISTER_PRIMITIVE_C(kNameIsClose, IsClose);
1040 MIND_API_OPERATOR_IMPL(IsClose, BaseOperator);
1041
1042 REGISTER_PRIMITIVE_C(kNameIsFinite, IsFinite);
1043 MIND_API_OPERATOR_IMPL(IsFinite, BaseOperator);
1044
1045 REGISTER_PRIMITIVE_C(kNameLayerNormExt, LayerNormExt);
1046 MIND_API_OPERATOR_IMPL(LayerNormExt, BaseOperator);
1047
1048 REGISTER_PRIMITIVE_C(kNameLayerNormGradExt, LayerNormGradExt);
1049 MIND_API_OPERATOR_IMPL(LayerNormGradExt, BaseOperator);
1050
set_begin_norm_axis(const int64_t & begin_norm_axis)1051 void LayerNormGradGrad::set_begin_norm_axis(const int64_t &begin_norm_axis) { (void)this->AddAttr("begin_norm_axis", api::MakeValue(begin_norm_axis)); }
1052
get_begin_norm_axis() const1053 int64_t LayerNormGradGrad::get_begin_norm_axis() const { return GetValue<int64_t>(GetAttr("begin_norm_axis")); }
1054
set_begin_params_axis(const int64_t & begin_params_axis)1055 void LayerNormGradGrad::set_begin_params_axis(const int64_t &begin_params_axis) { (void)this->AddAttr("begin_params_axis", api::MakeValue(begin_params_axis)); }
1056
get_begin_params_axis() const1057 int64_t LayerNormGradGrad::get_begin_params_axis() const { return GetValue<int64_t>(GetAttr("begin_params_axis")); }
1058
1059 REGISTER_PRIMITIVE_C(kNameLayerNormGradGrad, LayerNormGradGrad);
1060 MIND_API_OPERATOR_IMPL(LayerNormGradGrad, BaseOperator);
1061
set_begin_norm_axis(const int64_t & begin_norm_axis)1062 void LayerNormGrad::set_begin_norm_axis(const int64_t &begin_norm_axis) { (void)this->AddAttr("begin_norm_axis", api::MakeValue(begin_norm_axis)); }
1063
get_begin_norm_axis() const1064 int64_t LayerNormGrad::get_begin_norm_axis() const { return GetValue<int64_t>(GetAttr("begin_norm_axis")); }
1065
set_begin_params_axis(const int64_t & begin_params_axis)1066 void LayerNormGrad::set_begin_params_axis(const int64_t &begin_params_axis) { (void)this->AddAttr("begin_params_axis", api::MakeValue(begin_params_axis)); }
1067
get_begin_params_axis() const1068 int64_t LayerNormGrad::get_begin_params_axis() const { return GetValue<int64_t>(GetAttr("begin_params_axis")); }
1069
1070 REGISTER_PRIMITIVE_C(kNameLayerNormGrad, LayerNormGrad);
1071 MIND_API_OPERATOR_IMPL(LayerNormGrad, BaseOperator);
1072
set_begin_norm_axis(const int64_t & begin_norm_axis)1073 void LayerNormGradV3::set_begin_norm_axis(const int64_t &begin_norm_axis) { (void)this->AddAttr("begin_norm_axis", api::MakeValue(begin_norm_axis)); }
1074
get_begin_norm_axis() const1075 int64_t LayerNormGradV3::get_begin_norm_axis() const { return GetValue<int64_t>(GetAttr("begin_norm_axis")); }
1076
set_begin_params_axis(const int64_t & begin_params_axis)1077 void LayerNormGradV3::set_begin_params_axis(const int64_t &begin_params_axis) { (void)this->AddAttr("begin_params_axis", api::MakeValue(begin_params_axis)); }
1078
get_begin_params_axis() const1079 int64_t LayerNormGradV3::get_begin_params_axis() const { return GetValue<int64_t>(GetAttr("begin_params_axis")); }
1080
1081 REGISTER_PRIMITIVE_C(kNameLayerNormGradV3, LayerNormGradV3);
1082 MIND_API_OPERATOR_IMPL(LayerNormGradV3, BaseOperator);
1083
set_begin_norm_axis(const int64_t & begin_norm_axis)1084 void LayerNorm::set_begin_norm_axis(const int64_t &begin_norm_axis) { (void)this->AddAttr("begin_norm_axis", api::MakeValue(begin_norm_axis)); }
1085
get_begin_norm_axis() const1086 int64_t LayerNorm::get_begin_norm_axis() const { return GetValue<int64_t>(GetAttr("begin_norm_axis")); }
1087
set_begin_params_axis(const int64_t & begin_params_axis)1088 void LayerNorm::set_begin_params_axis(const int64_t &begin_params_axis) { (void)this->AddAttr("begin_params_axis", api::MakeValue(begin_params_axis)); }
1089
get_begin_params_axis() const1090 int64_t LayerNorm::get_begin_params_axis() const { return GetValue<int64_t>(GetAttr("begin_params_axis")); }
1091
set_epsilon(const float & epsilon)1092 void LayerNorm::set_epsilon(const float &epsilon) { (void)this->AddAttr("epsilon", api::MakeValue(epsilon)); }
1093
get_epsilon() const1094 float LayerNorm::get_epsilon() const { return GetValue<float>(GetAttr("epsilon")); }
1095
1096 REGISTER_PRIMITIVE_C(kNameLayerNorm, LayerNorm);
1097 MIND_API_OPERATOR_IMPL(LayerNorm, BaseOperator);
1098
set_begin_norm_axis(const int64_t & begin_norm_axis)1099 void LayerNormV3::set_begin_norm_axis(const int64_t &begin_norm_axis) { (void)this->AddAttr("begin_norm_axis", api::MakeValue(begin_norm_axis)); }
1100
get_begin_norm_axis() const1101 int64_t LayerNormV3::get_begin_norm_axis() const { return GetValue<int64_t>(GetAttr("begin_norm_axis")); }
1102
set_begin_params_axis(const int64_t & begin_params_axis)1103 void LayerNormV3::set_begin_params_axis(const int64_t &begin_params_axis) { (void)this->AddAttr("begin_params_axis", api::MakeValue(begin_params_axis)); }
1104
get_begin_params_axis() const1105 int64_t LayerNormV3::get_begin_params_axis() const { return GetValue<int64_t>(GetAttr("begin_params_axis")); }
1106
set_epsilon(const float & epsilon)1107 void LayerNormV3::set_epsilon(const float &epsilon) { (void)this->AddAttr("epsilon", api::MakeValue(epsilon)); }
1108
get_epsilon() const1109 float LayerNormV3::get_epsilon() const { return GetValue<float>(GetAttr("epsilon")); }
1110
1111 REGISTER_PRIMITIVE_C(kNameLayerNormV3, LayerNormV3);
1112 MIND_API_OPERATOR_IMPL(LayerNormV3, BaseOperator);
1113
1114 REGISTER_PRIMITIVE_C(kNameLeakyReLUExt, LeakyReLUExt);
1115 MIND_API_OPERATOR_IMPL(LeakyReLUExt, BaseOperator);
1116
1117 REGISTER_PRIMITIVE_C(kNameLeakyReLUGradExt, LeakyReLUGradExt);
1118 MIND_API_OPERATOR_IMPL(LeakyReLUGradExt, BaseOperator);
1119
1120 REGISTER_PRIMITIVE_C(kNameLessEqual, LessEqual);
1121 MIND_API_OPERATOR_IMPL(LessEqual, BaseOperator);
1122
1123 REGISTER_PRIMITIVE_C(kNameLess, Less);
1124 MIND_API_OPERATOR_IMPL(Less, BaseOperator);
1125
1126 REGISTER_PRIMITIVE_C(kNameLinSpaceExt, LinSpaceExt);
1127 MIND_API_OPERATOR_IMPL(LinSpaceExt, BaseOperator);
1128
1129 REGISTER_PRIMITIVE_C(kNameLinSpace, LinSpace);
1130 MIND_API_OPERATOR_IMPL(LinSpace, BaseOperator);
1131
1132 REGISTER_PRIMITIVE_C(kNameListToTuple, ListToTuple);
1133 MIND_API_OPERATOR_IMPL(ListToTuple, BaseOperator);
1134
1135 REGISTER_PRIMITIVE_C(kNameLog1p, Log1p);
1136 MIND_API_OPERATOR_IMPL(Log1p, BaseOperator);
1137
1138 REGISTER_PRIMITIVE_C(kNameLogMatrixDeterminant, LogMatrixDeterminant);
1139 MIND_API_OPERATOR_IMPL(LogMatrixDeterminant, BaseOperator);
1140
1141 REGISTER_PRIMITIVE_C(kNameLog, Log);
1142 MIND_API_OPERATOR_IMPL(Log, BaseOperator);
1143
set_axis(const int64_t & axis)1144 void LogSoftmaxGrad::set_axis(const int64_t &axis) { (void)this->AddAttr("axis", api::MakeValue(axis)); }
1145
get_axis() const1146 int64_t LogSoftmaxGrad::get_axis() const { return GetValue<int64_t>(GetAttr("axis")); }
1147
1148 REGISTER_PRIMITIVE_C(kNameLogSoftmaxGrad, LogSoftmaxGrad);
1149 MIND_API_OPERATOR_IMPL(LogSoftmaxGrad, BaseOperator);
1150
set_axis(const int64_t & axis)1151 void LogSoftmax::set_axis(const int64_t &axis) { (void)this->AddAttr("axis", api::MakeValue(axis)); }
1152
get_axis() const1153 int64_t LogSoftmax::get_axis() const { return GetValue<int64_t>(GetAttr("axis")); }
1154
1155 REGISTER_PRIMITIVE_C(kNameLogSoftmax, LogSoftmax);
1156 MIND_API_OPERATOR_IMPL(LogSoftmax, BaseOperator);
1157
1158 REGISTER_PRIMITIVE_C(kNameLogicalAnd, LogicalAnd);
1159 MIND_API_OPERATOR_IMPL(LogicalAnd, BaseOperator);
1160
1161 REGISTER_PRIMITIVE_C(kNameLogicalNot, LogicalNot);
1162 MIND_API_OPERATOR_IMPL(LogicalNot, BaseOperator);
1163
1164 REGISTER_PRIMITIVE_C(kNameLogicalOr, LogicalOr);
1165 MIND_API_OPERATOR_IMPL(LogicalOr, BaseOperator);
1166
1167 REGISTER_PRIMITIVE_C(kNameLogicalXor, LogicalXor);
1168 MIND_API_OPERATOR_IMPL(LogicalXor, BaseOperator);
1169
set_eps(const float & eps)1170 void LogitGrad::set_eps(const float &eps) { (void)this->AddAttr("eps", api::MakeValue(eps)); }
1171
get_eps() const1172 float LogitGrad::get_eps() const { return GetValue<float>(GetAttr("eps")); }
1173
1174 REGISTER_PRIMITIVE_C(kNameLogitGrad, LogitGrad);
1175 MIND_API_OPERATOR_IMPL(LogitGrad, BaseOperator);
1176
set_eps(const float & eps)1177 void Logit::set_eps(const float &eps) { (void)this->AddAttr("eps", api::MakeValue(eps)); }
1178
get_eps() const1179 float Logit::get_eps() const { return GetValue<float>(GetAttr("eps")); }
1180
1181 REGISTER_PRIMITIVE_C(kNameLogit, Logit);
1182 MIND_API_OPERATOR_IMPL(Logit, BaseOperator);
1183
1184 REGISTER_PRIMITIVE_C(kNameMaskedFill, MaskedFill);
1185 MIND_API_OPERATOR_IMPL(MaskedFill, BaseOperator);
1186
1187 REGISTER_PRIMITIVE_C(kNameMatMulExt, MatMulExt);
1188 MIND_API_OPERATOR_IMPL(MatMulExt, BaseOperator);
1189
set_transpose_a(const bool & transpose_a)1190 void MatMul::set_transpose_a(const bool &transpose_a) { (void)this->AddAttr("transpose_a", api::MakeValue(transpose_a)); }
1191
get_transpose_a() const1192 bool MatMul::get_transpose_a() const { return GetValue<bool>(GetAttr("transpose_a")); }
1193
set_transpose_b(const bool & transpose_b)1194 void MatMul::set_transpose_b(const bool &transpose_b) { (void)this->AddAttr("transpose_b", api::MakeValue(transpose_b)); }
1195
get_transpose_b() const1196 bool MatMul::get_transpose_b() const { return GetValue<bool>(GetAttr("transpose_b")); }
1197
1198 REGISTER_PRIMITIVE_C(kNameMatMul, MatMul);
1199 MIND_API_OPERATOR_IMPL(MatMul, BaseOperator);
1200
1201 REGISTER_PRIMITIVE_C(kNameMatrixDeterminant, MatrixDeterminant);
1202 MIND_API_OPERATOR_IMPL(MatrixDeterminant, BaseOperator);
1203
1204 REGISTER_PRIMITIVE_C(kNameMatrixExp, MatrixExp);
1205 MIND_API_OPERATOR_IMPL(MatrixExp, BaseOperator);
1206
1207 REGISTER_PRIMITIVE_C(kNameMatrixInverseExt, MatrixInverseExt);
1208 MIND_API_OPERATOR_IMPL(MatrixInverseExt, BaseOperator);
1209
1210 REGISTER_PRIMITIVE_C(kNameMax, Max);
1211 MIND_API_OPERATOR_IMPL(Max, BaseOperator);
1212
set_kernel_size(const std::vector<int64_t> & kernel_size)1213 void MaxPoolGradWithIndices::set_kernel_size(const std::vector<int64_t> &kernel_size) { (void)this->AddAttr("kernel_size", api::MakeValue(kernel_size)); }
1214
get_kernel_size() const1215 std::vector<int64_t> MaxPoolGradWithIndices::get_kernel_size() const { return GetValue<std::vector<int64_t>>(GetAttr("kernel_size")); }
1216
set_strides(const std::vector<int64_t> & strides)1217 void MaxPoolGradWithIndices::set_strides(const std::vector<int64_t> &strides) { (void)this->AddAttr("strides", api::MakeValue(strides)); }
1218
get_strides() const1219 std::vector<int64_t> MaxPoolGradWithIndices::get_strides() const { return GetValue<std::vector<int64_t>>(GetAttr("strides")); }
1220
set_pads(const std::vector<int64_t> & pads)1221 void MaxPoolGradWithIndices::set_pads(const std::vector<int64_t> &pads) { (void)this->AddAttr("pads", api::MakeValue(pads)); }
1222
get_pads() const1223 std::vector<int64_t> MaxPoolGradWithIndices::get_pads() const { return GetValue<std::vector<int64_t>>(GetAttr("pads")); }
1224
set_dilation(const std::vector<int64_t> & dilation)1225 void MaxPoolGradWithIndices::set_dilation(const std::vector<int64_t> &dilation) { (void)this->AddAttr("dilation", api::MakeValue(dilation)); }
1226
get_dilation() const1227 std::vector<int64_t> MaxPoolGradWithIndices::get_dilation() const { return GetValue<std::vector<int64_t>>(GetAttr("dilation")); }
1228
set_ceil_mode(const bool & ceil_mode)1229 void MaxPoolGradWithIndices::set_ceil_mode(const bool &ceil_mode) { (void)this->AddAttr("ceil_mode", api::MakeValue(ceil_mode)); }
1230
get_ceil_mode() const1231 bool MaxPoolGradWithIndices::get_ceil_mode() const { return GetValue<bool>(GetAttr("ceil_mode")); }
1232
set_argmax_type(const int64_t & argmax_type)1233 void MaxPoolGradWithIndices::set_argmax_type(const int64_t &argmax_type) { (void)this->AddAttr("argmax_type", api::MakeValue(argmax_type)); }
1234
get_argmax_type() const1235 int64_t MaxPoolGradWithIndices::get_argmax_type() const { return GetValue<int64_t>(GetAttr("argmax_type")); }
1236
1237 REGISTER_PRIMITIVE_C(kNameMaxPoolGradWithIndices, MaxPoolGradWithIndices);
1238 MIND_API_OPERATOR_IMPL(MaxPoolGradWithIndices, BaseOperator);
1239
set_kernel_size(const std::vector<int64_t> & kernel_size)1240 void MaxPoolGradWithMask::set_kernel_size(const std::vector<int64_t> &kernel_size) { (void)this->AddAttr("kernel_size", api::MakeValue(kernel_size)); }
1241
get_kernel_size() const1242 std::vector<int64_t> MaxPoolGradWithMask::get_kernel_size() const { return GetValue<std::vector<int64_t>>(GetAttr("kernel_size")); }
1243
set_strides(const std::vector<int64_t> & strides)1244 void MaxPoolGradWithMask::set_strides(const std::vector<int64_t> &strides) { (void)this->AddAttr("strides", api::MakeValue(strides)); }
1245
get_strides() const1246 std::vector<int64_t> MaxPoolGradWithMask::get_strides() const { return GetValue<std::vector<int64_t>>(GetAttr("strides")); }
1247
set_pads(const std::vector<int64_t> & pads)1248 void MaxPoolGradWithMask::set_pads(const std::vector<int64_t> &pads) { (void)this->AddAttr("pads", api::MakeValue(pads)); }
1249
get_pads() const1250 std::vector<int64_t> MaxPoolGradWithMask::get_pads() const { return GetValue<std::vector<int64_t>>(GetAttr("pads")); }
1251
set_dilation(const std::vector<int64_t> & dilation)1252 void MaxPoolGradWithMask::set_dilation(const std::vector<int64_t> &dilation) { (void)this->AddAttr("dilation", api::MakeValue(dilation)); }
1253
get_dilation() const1254 std::vector<int64_t> MaxPoolGradWithMask::get_dilation() const { return GetValue<std::vector<int64_t>>(GetAttr("dilation")); }
1255
set_ceil_mode(const bool & ceil_mode)1256 void MaxPoolGradWithMask::set_ceil_mode(const bool &ceil_mode) { (void)this->AddAttr("ceil_mode", api::MakeValue(ceil_mode)); }
1257
get_ceil_mode() const1258 bool MaxPoolGradWithMask::get_ceil_mode() const { return GetValue<bool>(GetAttr("ceil_mode")); }
1259
set_argmax_type(const int64_t & argmax_type)1260 void MaxPoolGradWithMask::set_argmax_type(const int64_t &argmax_type) { (void)this->AddAttr("argmax_type", api::MakeValue(argmax_type)); }
1261
get_argmax_type() const1262 int64_t MaxPoolGradWithMask::get_argmax_type() const { return GetValue<int64_t>(GetAttr("argmax_type")); }
1263
1264 REGISTER_PRIMITIVE_C(kNameMaxPoolGradWithMask, MaxPoolGradWithMask);
1265 MIND_API_OPERATOR_IMPL(MaxPoolGradWithMask, BaseOperator);
1266
set_kernel_size(const std::vector<int64_t> & kernel_size)1267 void MaxPoolWithIndices::set_kernel_size(const std::vector<int64_t> &kernel_size) { (void)this->AddAttr("kernel_size", api::MakeValue(kernel_size)); }
1268
get_kernel_size() const1269 std::vector<int64_t> MaxPoolWithIndices::get_kernel_size() const { return GetValue<std::vector<int64_t>>(GetAttr("kernel_size")); }
1270
set_strides(const std::vector<int64_t> & strides)1271 void MaxPoolWithIndices::set_strides(const std::vector<int64_t> &strides) { (void)this->AddAttr("strides", api::MakeValue(strides)); }
1272
get_strides() const1273 std::vector<int64_t> MaxPoolWithIndices::get_strides() const { return GetValue<std::vector<int64_t>>(GetAttr("strides")); }
1274
set_pads(const std::vector<int64_t> & pads)1275 void MaxPoolWithIndices::set_pads(const std::vector<int64_t> &pads) { (void)this->AddAttr("pads", api::MakeValue(pads)); }
1276
get_pads() const1277 std::vector<int64_t> MaxPoolWithIndices::get_pads() const { return GetValue<std::vector<int64_t>>(GetAttr("pads")); }
1278
set_dilation(const std::vector<int64_t> & dilation)1279 void MaxPoolWithIndices::set_dilation(const std::vector<int64_t> &dilation) { (void)this->AddAttr("dilation", api::MakeValue(dilation)); }
1280
get_dilation() const1281 std::vector<int64_t> MaxPoolWithIndices::get_dilation() const { return GetValue<std::vector<int64_t>>(GetAttr("dilation")); }
1282
set_ceil_mode(const bool & ceil_mode)1283 void MaxPoolWithIndices::set_ceil_mode(const bool &ceil_mode) { (void)this->AddAttr("ceil_mode", api::MakeValue(ceil_mode)); }
1284
get_ceil_mode() const1285 bool MaxPoolWithIndices::get_ceil_mode() const { return GetValue<bool>(GetAttr("ceil_mode")); }
1286
set_argmax_type(const int64_t & argmax_type)1287 void MaxPoolWithIndices::set_argmax_type(const int64_t &argmax_type) { (void)this->AddAttr("argmax_type", api::MakeValue(argmax_type)); }
1288
get_argmax_type() const1289 int64_t MaxPoolWithIndices::get_argmax_type() const { return GetValue<int64_t>(GetAttr("argmax_type")); }
1290
1291 REGISTER_PRIMITIVE_C(kNameMaxPoolWithIndices, MaxPoolWithIndices);
1292 MIND_API_OPERATOR_IMPL(MaxPoolWithIndices, BaseOperator);
1293
set_kernel_size(const std::vector<int64_t> & kernel_size)1294 void MaxPoolWithMask::set_kernel_size(const std::vector<int64_t> &kernel_size) { (void)this->AddAttr("kernel_size", api::MakeValue(kernel_size)); }
1295
get_kernel_size() const1296 std::vector<int64_t> MaxPoolWithMask::get_kernel_size() const { return GetValue<std::vector<int64_t>>(GetAttr("kernel_size")); }
1297
set_strides(const std::vector<int64_t> & strides)1298 void MaxPoolWithMask::set_strides(const std::vector<int64_t> &strides) { (void)this->AddAttr("strides", api::MakeValue(strides)); }
1299
get_strides() const1300 std::vector<int64_t> MaxPoolWithMask::get_strides() const { return GetValue<std::vector<int64_t>>(GetAttr("strides")); }
1301
set_pads(const std::vector<int64_t> & pads)1302 void MaxPoolWithMask::set_pads(const std::vector<int64_t> &pads) { (void)this->AddAttr("pads", api::MakeValue(pads)); }
1303
get_pads() const1304 std::vector<int64_t> MaxPoolWithMask::get_pads() const { return GetValue<std::vector<int64_t>>(GetAttr("pads")); }
1305
set_dilation(const std::vector<int64_t> & dilation)1306 void MaxPoolWithMask::set_dilation(const std::vector<int64_t> &dilation) { (void)this->AddAttr("dilation", api::MakeValue(dilation)); }
1307
get_dilation() const1308 std::vector<int64_t> MaxPoolWithMask::get_dilation() const { return GetValue<std::vector<int64_t>>(GetAttr("dilation")); }
1309
set_ceil_mode(const bool & ceil_mode)1310 void MaxPoolWithMask::set_ceil_mode(const bool &ceil_mode) { (void)this->AddAttr("ceil_mode", api::MakeValue(ceil_mode)); }
1311
get_ceil_mode() const1312 bool MaxPoolWithMask::get_ceil_mode() const { return GetValue<bool>(GetAttr("ceil_mode")); }
1313
set_argmax_type(const int64_t & argmax_type)1314 void MaxPoolWithMask::set_argmax_type(const int64_t &argmax_type) { (void)this->AddAttr("argmax_type", api::MakeValue(argmax_type)); }
1315
get_argmax_type() const1316 int64_t MaxPoolWithMask::get_argmax_type() const { return GetValue<int64_t>(GetAttr("argmax_type")); }
1317
1318 REGISTER_PRIMITIVE_C(kNameMaxPoolWithMask, MaxPoolWithMask);
1319 MIND_API_OPERATOR_IMPL(MaxPoolWithMask, BaseOperator);
1320
set_grad_x(const bool & grad_x)1321 void MaximumGradGrad::set_grad_x(const bool &grad_x) { (void)this->AddAttr("grad_x", api::MakeValue(grad_x)); }
1322
get_grad_x() const1323 bool MaximumGradGrad::get_grad_x() const { return GetValue<bool>(GetAttr("grad_x")); }
1324
set_grad_y(const bool & grad_y)1325 void MaximumGradGrad::set_grad_y(const bool &grad_y) { (void)this->AddAttr("grad_y", api::MakeValue(grad_y)); }
1326
get_grad_y() const1327 bool MaximumGradGrad::get_grad_y() const { return GetValue<bool>(GetAttr("grad_y")); }
1328
1329 REGISTER_PRIMITIVE_C(kNameMaximumGradGrad, MaximumGradGrad);
1330 MIND_API_OPERATOR_IMPL(MaximumGradGrad, BaseOperator);
1331
set_grad_x(const bool & grad_x)1332 void MaximumGrad::set_grad_x(const bool &grad_x) { (void)this->AddAttr("grad_x", api::MakeValue(grad_x)); }
1333
get_grad_x() const1334 bool MaximumGrad::get_grad_x() const { return GetValue<bool>(GetAttr("grad_x")); }
1335
set_grad_y(const bool & grad_y)1336 void MaximumGrad::set_grad_y(const bool &grad_y) { (void)this->AddAttr("grad_y", api::MakeValue(grad_y)); }
1337
get_grad_y() const1338 bool MaximumGrad::get_grad_y() const { return GetValue<bool>(GetAttr("grad_y")); }
1339
1340 REGISTER_PRIMITIVE_C(kNameMaximumGrad, MaximumGrad);
1341 MIND_API_OPERATOR_IMPL(MaximumGrad, BaseOperator);
1342
1343 REGISTER_PRIMITIVE_C(kNameMaximum, Maximum);
1344 MIND_API_OPERATOR_IMPL(Maximum, BaseOperator);
1345
1346 REGISTER_PRIMITIVE_C(kNameMeanExt, MeanExt);
1347 MIND_API_OPERATOR_IMPL(MeanExt, BaseOperator);
1348
1349 REGISTER_PRIMITIVE_C(kNameMin, Min);
1350 MIND_API_OPERATOR_IMPL(Min, BaseOperator);
1351
set_grad_x(const bool & grad_x)1352 void MinimumGrad::set_grad_x(const bool &grad_x) { (void)this->AddAttr("grad_x", api::MakeValue(grad_x)); }
1353
get_grad_x() const1354 bool MinimumGrad::get_grad_x() const { return GetValue<bool>(GetAttr("grad_x")); }
1355
set_grad_y(const bool & grad_y)1356 void MinimumGrad::set_grad_y(const bool &grad_y) { (void)this->AddAttr("grad_y", api::MakeValue(grad_y)); }
1357
get_grad_y() const1358 bool MinimumGrad::get_grad_y() const { return GetValue<bool>(GetAttr("grad_y")); }
1359
1360 REGISTER_PRIMITIVE_C(kNameMinimumGrad, MinimumGrad);
1361 MIND_API_OPERATOR_IMPL(MinimumGrad, BaseOperator);
1362
1363 REGISTER_PRIMITIVE_C(kNameMinimum, Minimum);
1364 MIND_API_OPERATOR_IMPL(Minimum, BaseOperator);
1365
1366 REGISTER_PRIMITIVE_C(kNameMul, Mul);
1367 MIND_API_OPERATOR_IMPL(Mul, BaseOperator);
1368
1369 REGISTER_PRIMITIVE_C(kNameMv, Mv);
1370 MIND_API_OPERATOR_IMPL(Mv, BaseOperator);
1371
set_nan(const float & nan)1372 void NanToNum::set_nan(const float &nan) { (void)this->AddAttr("nan", api::MakeValue(nan)); }
1373
get_nan() const1374 float NanToNum::get_nan() const { return GetValue<float>(GetAttr("nan")); }
1375
set_posinf(const float & posinf)1376 void NanToNum::set_posinf(const float &posinf) { (void)this->AddAttr("posinf", api::MakeValue(posinf)); }
1377
get_posinf() const1378 float NanToNum::get_posinf() const { return GetValue<float>(GetAttr("posinf")); }
1379
set_neginf(const float & neginf)1380 void NanToNum::set_neginf(const float &neginf) { (void)this->AddAttr("neginf", api::MakeValue(neginf)); }
1381
get_neginf() const1382 float NanToNum::get_neginf() const { return GetValue<float>(GetAttr("neginf")); }
1383
1384 REGISTER_PRIMITIVE_C(kNameNanToNum, NanToNum);
1385 MIND_API_OPERATOR_IMPL(NanToNum, BaseOperator);
1386
1387 REGISTER_PRIMITIVE_C(kNameNeg, Neg);
1388 MIND_API_OPERATOR_IMPL(Neg, BaseOperator);
1389
1390 REGISTER_PRIMITIVE_C(kNameNextAfter, NextAfter);
1391 MIND_API_OPERATOR_IMPL(NextAfter, BaseOperator);
1392
set_reduction(const int64_t & reduction)1393 void NLLLossGrad::set_reduction(const int64_t &reduction) { (void)this->AddAttr("reduction", api::MakeValue(reduction)); }
1394
get_reduction() const1395 int64_t NLLLossGrad::get_reduction() const { return GetValue<int64_t>(GetAttr("reduction")); }
1396
set_ignore_index(const int64_t & ignore_index)1397 void NLLLossGrad::set_ignore_index(const int64_t &ignore_index) { (void)this->AddAttr("ignore_index", api::MakeValue(ignore_index)); }
1398
get_ignore_index() const1399 int64_t NLLLossGrad::get_ignore_index() const { return GetValue<int64_t>(GetAttr("ignore_index")); }
1400
1401 REGISTER_PRIMITIVE_C(kNameNLLLossGrad, NLLLossGrad);
1402 MIND_API_OPERATOR_IMPL(NLLLossGrad, BaseOperator);
1403
set_reduction(const int64_t & reduction)1404 void NLLLoss::set_reduction(const int64_t &reduction) { (void)this->AddAttr("reduction", api::MakeValue(reduction)); }
1405
get_reduction() const1406 int64_t NLLLoss::get_reduction() const { return GetValue<int64_t>(GetAttr("reduction")); }
1407
set_ignore_index(const int64_t & ignore_index)1408 void NLLLoss::set_ignore_index(const int64_t &ignore_index) { (void)this->AddAttr("ignore_index", api::MakeValue(ignore_index)); }
1409
get_ignore_index() const1410 int64_t NLLLoss::get_ignore_index() const { return GetValue<int64_t>(GetAttr("ignore_index")); }
1411
1412 REGISTER_PRIMITIVE_C(kNameNLLLoss, NLLLoss);
1413 MIND_API_OPERATOR_IMPL(NLLLoss, BaseOperator);
1414
1415 REGISTER_PRIMITIVE_C(kNameNonZeroExt, NonZeroExt);
1416 MIND_API_OPERATOR_IMPL(NonZeroExt, BaseOperator);
1417
1418 REGISTER_PRIMITIVE_C(kNameNonZero, NonZero);
1419 MIND_API_OPERATOR_IMPL(NonZero, BaseOperator);
1420
1421 REGISTER_PRIMITIVE_C(kNameNorm, Norm);
1422 MIND_API_OPERATOR_IMPL(Norm, BaseOperator);
1423
1424 REGISTER_PRIMITIVE_C(kNameNormalFloatFloat, NormalFloatFloat);
1425 MIND_API_OPERATOR_IMPL(NormalFloatFloat, BaseOperator);
1426
1427 REGISTER_PRIMITIVE_C(kNameNormalFloatTensor, NormalFloatTensor);
1428 MIND_API_OPERATOR_IMPL(NormalFloatTensor, BaseOperator);
1429
1430 REGISTER_PRIMITIVE_C(kNameNormalTensorFloat, NormalTensorFloat);
1431 MIND_API_OPERATOR_IMPL(NormalTensorFloat, BaseOperator);
1432
1433 REGISTER_PRIMITIVE_C(kNameNormalTensorTensor, NormalTensorTensor);
1434 MIND_API_OPERATOR_IMPL(NormalTensorTensor, BaseOperator);
1435
1436 REGISTER_PRIMITIVE_C(kNameNotEqual, NotEqual);
1437 MIND_API_OPERATOR_IMPL(NotEqual, BaseOperator);
1438
1439 REGISTER_PRIMITIVE_C(kNameNPUClearFloatStatusV2, NPUClearFloatStatusV2);
1440 MIND_API_OPERATOR_IMPL(NPUClearFloatStatusV2, BaseOperator);
1441
1442 REGISTER_PRIMITIVE_C(kNameNPUGetFloatStatusV2, NPUGetFloatStatusV2);
1443 MIND_API_OPERATOR_IMPL(NPUGetFloatStatusV2, BaseOperator);
1444
set_axis(const int64_t & axis)1445 void OneHotExt::set_axis(const int64_t &axis) { (void)this->AddAttr("axis", api::MakeValue(axis)); }
1446
get_axis() const1447 int64_t OneHotExt::get_axis() const { return GetValue<int64_t>(GetAttr("axis")); }
1448
1449 REGISTER_PRIMITIVE_C(kNameOneHotExt, OneHotExt);
1450 MIND_API_OPERATOR_IMPL(OneHotExt, BaseOperator);
1451
set_axis(const int64_t & axis)1452 void OneHot::set_axis(const int64_t &axis) { (void)this->AddAttr("axis", api::MakeValue(axis)); }
1453
get_axis() const1454 int64_t OneHot::get_axis() const { return GetValue<int64_t>(GetAttr("axis")); }
1455
1456 REGISTER_PRIMITIVE_C(kNameOneHot, OneHot);
1457 MIND_API_OPERATOR_IMPL(OneHot, BaseOperator);
1458
1459 REGISTER_PRIMITIVE_C(kNameOnesLikeExt, OnesLikeExt);
1460 MIND_API_OPERATOR_IMPL(OnesLikeExt, BaseOperator);
1461
1462 REGISTER_PRIMITIVE_C(kNameOnesLike, OnesLike);
1463 MIND_API_OPERATOR_IMPL(OnesLike, BaseOperator);
1464
1465 REGISTER_PRIMITIVE_C(kNameOnes, Ones);
1466 MIND_API_OPERATOR_IMPL(Ones, BaseOperator);
1467
set_head_num(const int64_t & head_num)1468 void PagedAttentionMask::set_head_num(const int64_t &head_num) { (void)this->AddAttr("head_num", api::MakeValue(head_num)); }
1469
get_head_num() const1470 int64_t PagedAttentionMask::get_head_num() const { return GetValue<int64_t>(GetAttr("head_num")); }
1471
set_scale_value(const float & scale_value)1472 void PagedAttentionMask::set_scale_value(const float &scale_value) { (void)this->AddAttr("scale_value", api::MakeValue(scale_value)); }
1473
get_scale_value() const1474 float PagedAttentionMask::get_scale_value() const { return GetValue<float>(GetAttr("scale_value")); }
1475
set_kv_head_num(const int64_t & kv_head_num)1476 void PagedAttentionMask::set_kv_head_num(const int64_t &kv_head_num) { (void)this->AddAttr("kv_head_num", api::MakeValue(kv_head_num)); }
1477
get_kv_head_num() const1478 int64_t PagedAttentionMask::get_kv_head_num() const { return GetValue<int64_t>(GetAttr("kv_head_num")); }
1479
1480 REGISTER_PRIMITIVE_C(kNamePagedAttentionMask, PagedAttentionMask);
1481 MIND_API_OPERATOR_IMPL(PagedAttentionMask, BaseOperator);
1482
set_head_num(const int64_t & head_num)1483 void PagedAttention::set_head_num(const int64_t &head_num) { (void)this->AddAttr("head_num", api::MakeValue(head_num)); }
1484
get_head_num() const1485 int64_t PagedAttention::get_head_num() const { return GetValue<int64_t>(GetAttr("head_num")); }
1486
set_scale_value(const float & scale_value)1487 void PagedAttention::set_scale_value(const float &scale_value) { (void)this->AddAttr("scale_value", api::MakeValue(scale_value)); }
1488
get_scale_value() const1489 float PagedAttention::get_scale_value() const { return GetValue<float>(GetAttr("scale_value")); }
1490
set_kv_head_num(const int64_t & kv_head_num)1491 void PagedAttention::set_kv_head_num(const int64_t &kv_head_num) { (void)this->AddAttr("kv_head_num", api::MakeValue(kv_head_num)); }
1492
get_kv_head_num() const1493 int64_t PagedAttention::get_kv_head_num() const { return GetValue<int64_t>(GetAttr("kv_head_num")); }
1494
1495 REGISTER_PRIMITIVE_C(kNamePagedAttention, PagedAttention);
1496 MIND_API_OPERATOR_IMPL(PagedAttention, BaseOperator);
1497
1498 REGISTER_PRIMITIVE_C(kNamePow, Pow);
1499 MIND_API_OPERATOR_IMPL(Pow, BaseOperator);
1500
1501 REGISTER_PRIMITIVE_C(kNamePReLUGrad, PReLUGrad);
1502 MIND_API_OPERATOR_IMPL(PReLUGrad, BaseOperator);
1503
1504 REGISTER_PRIMITIVE_C(kNamePReLU, PReLU);
1505 MIND_API_OPERATOR_IMPL(PReLU, BaseOperator);
1506
1507 REGISTER_PRIMITIVE_C(kNameProdExt, ProdExt);
1508 MIND_API_OPERATOR_IMPL(ProdExt, BaseOperator);
1509
set_align_mode(const int64_t & align_mode)1510 void PromptKVCache::set_align_mode(const int64_t &align_mode) { (void)this->AddAttr("align_mode", api::MakeValue(align_mode)); }
1511
get_align_mode() const1512 int64_t PromptKVCache::get_align_mode() const { return GetValue<int64_t>(GetAttr("align_mode")); }
1513
1514 REGISTER_PRIMITIVE_C(kNamePromptKVCache, PromptKVCache);
1515 MIND_API_OPERATOR_IMPL(PromptKVCache, BaseOperator);
1516
set_full_matrices(const bool & full_matrices)1517 void Qr::set_full_matrices(const bool &full_matrices) { (void)this->AddAttr("full_matrices", api::MakeValue(full_matrices)); }
1518
get_full_matrices() const1519 bool Qr::get_full_matrices() const { return GetValue<bool>(GetAttr("full_matrices")); }
1520
1521 REGISTER_PRIMITIVE_C(kNameQr, Qr);
1522 MIND_API_OPERATOR_IMPL(Qr, BaseOperator);
1523
1524 REGISTER_PRIMITIVE_C(kNameRandExt, RandExt);
1525 MIND_API_OPERATOR_IMPL(RandExt, BaseOperator);
1526
1527 REGISTER_PRIMITIVE_C(kNameRandLikeExt, RandLikeExt);
1528 MIND_API_OPERATOR_IMPL(RandLikeExt, BaseOperator);
1529
set_seed(const int64_t & seed)1530 void RandpermV2::set_seed(const int64_t &seed) { (void)this->AddAttr("seed", api::MakeValue(seed)); }
1531
get_seed() const1532 int64_t RandpermV2::get_seed() const { return GetValue<int64_t>(GetAttr("seed")); }
1533
set_offset(const int64_t & offset)1534 void RandpermV2::set_offset(const int64_t &offset) { (void)this->AddAttr("offset", api::MakeValue(offset)); }
1535
get_offset() const1536 int64_t RandpermV2::get_offset() const { return GetValue<int64_t>(GetAttr("offset")); }
1537
set_dtype(const int64_t & dtype)1538 void RandpermV2::set_dtype(const int64_t &dtype) { (void)this->AddAttr("dtype", api::MakeValue(dtype)); }
1539
get_dtype() const1540 int64_t RandpermV2::get_dtype() const { return GetValue<int64_t>(GetAttr("dtype")); }
1541
1542 REGISTER_PRIMITIVE_C(kNameRandpermV2, RandpermV2);
1543 MIND_API_OPERATOR_IMPL(RandpermV2, BaseOperator);
1544
set_maxlen(const int64_t & maxlen)1545 void Range::set_maxlen(const int64_t &maxlen) { (void)this->AddAttr("maxlen", api::MakeValue(maxlen)); }
1546
get_maxlen() const1547 int64_t Range::get_maxlen() const { return GetValue<int64_t>(GetAttr("maxlen")); }
1548
1549 REGISTER_PRIMITIVE_C(kNameRange, Range);
1550 MIND_API_OPERATOR_IMPL(Range, BaseOperator);
1551
1552 REGISTER_PRIMITIVE_C(kNameRank, Rank);
1553 MIND_API_OPERATOR_IMPL(Rank, BaseOperator);
1554
1555 REGISTER_PRIMITIVE_C(kNameRealDiv, RealDiv);
1556 MIND_API_OPERATOR_IMPL(RealDiv, BaseOperator);
1557
1558 REGISTER_PRIMITIVE_C(kNameReal, Real);
1559 MIND_API_OPERATOR_IMPL(Real, BaseOperator);
1560
1561 REGISTER_PRIMITIVE_C(kNameReciprocalGrad, ReciprocalGrad);
1562 MIND_API_OPERATOR_IMPL(ReciprocalGrad, BaseOperator);
1563
1564 REGISTER_PRIMITIVE_C(kNameReciprocal, Reciprocal);
1565 MIND_API_OPERATOR_IMPL(Reciprocal, BaseOperator);
1566
set_keep_dims(const bool & keep_dims)1567 void ReduceAll::set_keep_dims(const bool &keep_dims) { (void)this->AddAttr("keep_dims", api::MakeValue(keep_dims)); }
1568
get_keep_dims() const1569 bool ReduceAll::get_keep_dims() const { return GetValue<bool>(GetAttr("keep_dims")); }
1570
1571 REGISTER_PRIMITIVE_C(kNameReduceAll, ReduceAll);
1572 MIND_API_OPERATOR_IMPL(ReduceAll, BaseOperator);
1573
set_keep_dims(const bool & keep_dims)1574 void ReduceAny::set_keep_dims(const bool &keep_dims) { (void)this->AddAttr("keep_dims", api::MakeValue(keep_dims)); }
1575
get_keep_dims() const1576 bool ReduceAny::get_keep_dims() const { return GetValue<bool>(GetAttr("keep_dims")); }
1577
1578 REGISTER_PRIMITIVE_C(kNameReduceAny, ReduceAny);
1579 MIND_API_OPERATOR_IMPL(ReduceAny, BaseOperator);
1580
set_keep_dims(const bool & keep_dims)1581 void ReduceMax::set_keep_dims(const bool &keep_dims) { (void)this->AddAttr("keep_dims", api::MakeValue(keep_dims)); }
1582
get_keep_dims() const1583 bool ReduceMax::get_keep_dims() const { return GetValue<bool>(GetAttr("keep_dims")); }
1584
1585 REGISTER_PRIMITIVE_C(kNameReduceMax, ReduceMax);
1586 MIND_API_OPERATOR_IMPL(ReduceMax, BaseOperator);
1587
set_keep_dims(const bool & keep_dims)1588 void ReduceMean::set_keep_dims(const bool &keep_dims) { (void)this->AddAttr("keep_dims", api::MakeValue(keep_dims)); }
1589
get_keep_dims() const1590 bool ReduceMean::get_keep_dims() const { return GetValue<bool>(GetAttr("keep_dims")); }
1591
1592 REGISTER_PRIMITIVE_C(kNameReduceMean, ReduceMean);
1593 MIND_API_OPERATOR_IMPL(ReduceMean, BaseOperator);
1594
set_keep_dims(const bool & keep_dims)1595 void ReduceMin::set_keep_dims(const bool &keep_dims) { (void)this->AddAttr("keep_dims", api::MakeValue(keep_dims)); }
1596
get_keep_dims() const1597 bool ReduceMin::get_keep_dims() const { return GetValue<bool>(GetAttr("keep_dims")); }
1598
1599 REGISTER_PRIMITIVE_C(kNameReduceMin, ReduceMin);
1600 MIND_API_OPERATOR_IMPL(ReduceMin, BaseOperator);
1601
set_keep_dims(const bool & keep_dims)1602 void ReduceProd::set_keep_dims(const bool &keep_dims) { (void)this->AddAttr("keep_dims", api::MakeValue(keep_dims)); }
1603
get_keep_dims() const1604 bool ReduceProd::get_keep_dims() const { return GetValue<bool>(GetAttr("keep_dims")); }
1605
1606 REGISTER_PRIMITIVE_C(kNameReduceProd, ReduceProd);
1607 MIND_API_OPERATOR_IMPL(ReduceProd, BaseOperator);
1608
set_axis(const std::vector<int64_t> & axis)1609 void ReduceStd::set_axis(const std::vector<int64_t> &axis) { (void)this->AddAttr("axis", api::MakeValue(axis)); }
1610
get_axis() const1611 std::vector<int64_t> ReduceStd::get_axis() const { return GetValue<std::vector<int64_t>>(GetAttr("axis")); }
1612
set_unbiased(const bool & unbiased)1613 void ReduceStd::set_unbiased(const bool &unbiased) { (void)this->AddAttr("unbiased", api::MakeValue(unbiased)); }
1614
get_unbiased() const1615 bool ReduceStd::get_unbiased() const { return GetValue<bool>(GetAttr("unbiased")); }
1616
set_keep_dims(const bool & keep_dims)1617 void ReduceStd::set_keep_dims(const bool &keep_dims) { (void)this->AddAttr("keep_dims", api::MakeValue(keep_dims)); }
1618
get_keep_dims() const1619 bool ReduceStd::get_keep_dims() const { return GetValue<bool>(GetAttr("keep_dims")); }
1620
1621 REGISTER_PRIMITIVE_C(kNameReduceStd, ReduceStd);
1622 MIND_API_OPERATOR_IMPL(ReduceStd, BaseOperator);
1623
set_keep_dims(const bool & keep_dims)1624 void ReduceSum::set_keep_dims(const bool &keep_dims) { (void)this->AddAttr("keep_dims", api::MakeValue(keep_dims)); }
1625
get_keep_dims() const1626 bool ReduceSum::get_keep_dims() const { return GetValue<bool>(GetAttr("keep_dims")); }
1627
set_skip_mode(const bool & skip_mode)1628 void ReduceSum::set_skip_mode(const bool &skip_mode) { (void)this->AddAttr("skip_mode", api::MakeValue(skip_mode)); }
1629
get_skip_mode() const1630 bool ReduceSum::get_skip_mode() const { return GetValue<bool>(GetAttr("skip_mode")); }
1631
1632 REGISTER_PRIMITIVE_C(kNameReduceSum, ReduceSum);
1633 MIND_API_OPERATOR_IMPL(ReduceSum, BaseOperator);
1634
1635 REGISTER_PRIMITIVE_C(kNameReflectionPad1DGrad, ReflectionPad1DGrad);
1636 MIND_API_OPERATOR_IMPL(ReflectionPad1DGrad, BaseOperator);
1637
1638 REGISTER_PRIMITIVE_C(kNameReflectionPad1D, ReflectionPad1D);
1639 MIND_API_OPERATOR_IMPL(ReflectionPad1D, BaseOperator);
1640
1641 REGISTER_PRIMITIVE_C(kNameReflectionPad2DGrad, ReflectionPad2DGrad);
1642 MIND_API_OPERATOR_IMPL(ReflectionPad2DGrad, BaseOperator);
1643
1644 REGISTER_PRIMITIVE_C(kNameReflectionPad2D, ReflectionPad2D);
1645 MIND_API_OPERATOR_IMPL(ReflectionPad2D, BaseOperator);
1646
1647 REGISTER_PRIMITIVE_C(kNameReflectionPad3DGrad, ReflectionPad3DGrad);
1648 MIND_API_OPERATOR_IMPL(ReflectionPad3DGrad, BaseOperator);
1649
1650 REGISTER_PRIMITIVE_C(kNameReflectionPad3D, ReflectionPad3D);
1651 MIND_API_OPERATOR_IMPL(ReflectionPad3D, BaseOperator);
1652
1653 REGISTER_PRIMITIVE_C(kNameReLU6Grad, ReLU6Grad);
1654 MIND_API_OPERATOR_IMPL(ReLU6Grad, BaseOperator);
1655
1656 REGISTER_PRIMITIVE_C(kNameReLU6, ReLU6);
1657 MIND_API_OPERATOR_IMPL(ReLU6, BaseOperator);
1658
1659 REGISTER_PRIMITIVE_C(kNameReluGrad, ReluGrad);
1660 MIND_API_OPERATOR_IMPL(ReluGrad, BaseOperator);
1661
1662 REGISTER_PRIMITIVE_C(kNameReLU, ReLU);
1663 MIND_API_OPERATOR_IMPL(ReLU, BaseOperator);
1664
1665 REGISTER_PRIMITIVE_C(kNameRepeatInterleaveGrad, RepeatInterleaveGrad);
1666 MIND_API_OPERATOR_IMPL(RepeatInterleaveGrad, BaseOperator);
1667
1668 REGISTER_PRIMITIVE_C(kNameRepeatInterleaveInt, RepeatInterleaveInt);
1669 MIND_API_OPERATOR_IMPL(RepeatInterleaveInt, BaseOperator);
1670
1671 REGISTER_PRIMITIVE_C(kNameRepeatInterleaveTensor, RepeatInterleaveTensor);
1672 MIND_API_OPERATOR_IMPL(RepeatInterleaveTensor, BaseOperator);
1673
1674 REGISTER_PRIMITIVE_C(kNameReplicationPad1DGrad, ReplicationPad1DGrad);
1675 MIND_API_OPERATOR_IMPL(ReplicationPad1DGrad, BaseOperator);
1676
1677 REGISTER_PRIMITIVE_C(kNameReplicationPad1D, ReplicationPad1D);
1678 MIND_API_OPERATOR_IMPL(ReplicationPad1D, BaseOperator);
1679
1680 REGISTER_PRIMITIVE_C(kNameReplicationPad2DGrad, ReplicationPad2DGrad);
1681 MIND_API_OPERATOR_IMPL(ReplicationPad2DGrad, BaseOperator);
1682
1683 REGISTER_PRIMITIVE_C(kNameReplicationPad2D, ReplicationPad2D);
1684 MIND_API_OPERATOR_IMPL(ReplicationPad2D, BaseOperator);
1685
1686 REGISTER_PRIMITIVE_C(kNameReplicationPad3DGrad, ReplicationPad3DGrad);
1687 MIND_API_OPERATOR_IMPL(ReplicationPad3DGrad, BaseOperator);
1688
1689 REGISTER_PRIMITIVE_C(kNameReplicationPad3D, ReplicationPad3D);
1690 MIND_API_OPERATOR_IMPL(ReplicationPad3D, BaseOperator);
1691
1692 REGISTER_PRIMITIVE_C(kNameReshapeAndCache, ReshapeAndCache);
1693 MIND_API_OPERATOR_IMPL(ReshapeAndCache, BaseOperator);
1694
1695 REGISTER_PRIMITIVE_C(kNameReshape, Reshape);
1696 MIND_API_OPERATOR_IMPL(Reshape, BaseOperator);
1697
set_align_corners(const bool & align_corners)1698 void ResizeBicubicGrad::set_align_corners(const bool &align_corners) { (void)this->AddAttr("align_corners", api::MakeValue(align_corners)); }
1699
get_align_corners() const1700 bool ResizeBicubicGrad::get_align_corners() const { return GetValue<bool>(GetAttr("align_corners")); }
1701
set_half_pixel_centers(const bool & half_pixel_centers)1702 void ResizeBicubicGrad::set_half_pixel_centers(const bool &half_pixel_centers) { (void)this->AddAttr("half_pixel_centers", api::MakeValue(half_pixel_centers)); }
1703
get_half_pixel_centers() const1704 bool ResizeBicubicGrad::get_half_pixel_centers() const { return GetValue<bool>(GetAttr("half_pixel_centers")); }
1705
1706 REGISTER_PRIMITIVE_C(kNameResizeBicubicGrad, ResizeBicubicGrad);
1707 MIND_API_OPERATOR_IMPL(ResizeBicubicGrad, BaseOperator);
1708
set_align_corners(const bool & align_corners)1709 void ResizeBicubic::set_align_corners(const bool &align_corners) { (void)this->AddAttr("align_corners", api::MakeValue(align_corners)); }
1710
get_align_corners() const1711 bool ResizeBicubic::get_align_corners() const { return GetValue<bool>(GetAttr("align_corners")); }
1712
set_half_pixel_centers(const bool & half_pixel_centers)1713 void ResizeBicubic::set_half_pixel_centers(const bool &half_pixel_centers) { (void)this->AddAttr("half_pixel_centers", api::MakeValue(half_pixel_centers)); }
1714
get_half_pixel_centers() const1715 bool ResizeBicubic::get_half_pixel_centers() const { return GetValue<bool>(GetAttr("half_pixel_centers")); }
1716
1717 REGISTER_PRIMITIVE_C(kNameResizeBicubic, ResizeBicubic);
1718 MIND_API_OPERATOR_IMPL(ResizeBicubic, BaseOperator);
1719
set_align_corners(const bool & align_corners)1720 void ResizeBilinearGrad::set_align_corners(const bool &align_corners) { (void)this->AddAttr("align_corners", api::MakeValue(align_corners)); }
1721
get_align_corners() const1722 bool ResizeBilinearGrad::get_align_corners() const { return GetValue<bool>(GetAttr("align_corners")); }
1723
set_half_pixel_centers(const bool & half_pixel_centers)1724 void ResizeBilinearGrad::set_half_pixel_centers(const bool &half_pixel_centers) { (void)this->AddAttr("half_pixel_centers", api::MakeValue(half_pixel_centers)); }
1725
get_half_pixel_centers() const1726 bool ResizeBilinearGrad::get_half_pixel_centers() const { return GetValue<bool>(GetAttr("half_pixel_centers")); }
1727
1728 REGISTER_PRIMITIVE_C(kNameResizeBilinearGrad, ResizeBilinearGrad);
1729 MIND_API_OPERATOR_IMPL(ResizeBilinearGrad, BaseOperator);
1730
set_align_corners(const bool & align_corners)1731 void ResizeBilinearV2::set_align_corners(const bool &align_corners) { (void)this->AddAttr("align_corners", api::MakeValue(align_corners)); }
1732
get_align_corners() const1733 bool ResizeBilinearV2::get_align_corners() const { return GetValue<bool>(GetAttr("align_corners")); }
1734
set_half_pixel_centers(const bool & half_pixel_centers)1735 void ResizeBilinearV2::set_half_pixel_centers(const bool &half_pixel_centers) { (void)this->AddAttr("half_pixel_centers", api::MakeValue(half_pixel_centers)); }
1736
get_half_pixel_centers() const1737 bool ResizeBilinearV2::get_half_pixel_centers() const { return GetValue<bool>(GetAttr("half_pixel_centers")); }
1738
1739 REGISTER_PRIMITIVE_C(kNameResizeBilinearV2, ResizeBilinearV2);
1740 MIND_API_OPERATOR_IMPL(ResizeBilinearV2, BaseOperator);
1741
1742 REGISTER_PRIMITIVE_C(kNameResizeD, ResizeD);
1743 MIND_API_OPERATOR_IMPL(ResizeD, BaseOperator);
1744
set_coordinate_transformation_mode(const int64_t & coordinate_transformation_mode)1745 void ResizeLinear1DGrad::set_coordinate_transformation_mode(const int64_t &coordinate_transformation_mode) { (void)this->AddAttr("coordinate_transformation_mode", api::MakeValue(coordinate_transformation_mode)); }
1746
get_coordinate_transformation_mode() const1747 int64_t ResizeLinear1DGrad::get_coordinate_transformation_mode() const { return GetValue<int64_t>(GetAttr("coordinate_transformation_mode")); }
1748
1749 REGISTER_PRIMITIVE_C(kNameResizeLinear1DGrad, ResizeLinear1DGrad);
1750 MIND_API_OPERATOR_IMPL(ResizeLinear1DGrad, BaseOperator);
1751
set_coordinate_transformation_mode(const int64_t & coordinate_transformation_mode)1752 void ResizeLinear1D::set_coordinate_transformation_mode(const int64_t &coordinate_transformation_mode) { (void)this->AddAttr("coordinate_transformation_mode", api::MakeValue(coordinate_transformation_mode)); }
1753
get_coordinate_transformation_mode() const1754 int64_t ResizeLinear1D::get_coordinate_transformation_mode() const { return GetValue<int64_t>(GetAttr("coordinate_transformation_mode")); }
1755
1756 REGISTER_PRIMITIVE_C(kNameResizeLinear1D, ResizeLinear1D);
1757 MIND_API_OPERATOR_IMPL(ResizeLinear1D, BaseOperator);
1758
set_align_corners(const bool & align_corners)1759 void ResizeNearestNeighborGrad::set_align_corners(const bool &align_corners) { (void)this->AddAttr("align_corners", api::MakeValue(align_corners)); }
1760
get_align_corners() const1761 bool ResizeNearestNeighborGrad::get_align_corners() const { return GetValue<bool>(GetAttr("align_corners")); }
1762
set_half_pixel_centers(const bool & half_pixel_centers)1763 void ResizeNearestNeighborGrad::set_half_pixel_centers(const bool &half_pixel_centers) { (void)this->AddAttr("half_pixel_centers", api::MakeValue(half_pixel_centers)); }
1764
get_half_pixel_centers() const1765 bool ResizeNearestNeighborGrad::get_half_pixel_centers() const { return GetValue<bool>(GetAttr("half_pixel_centers")); }
1766
1767 REGISTER_PRIMITIVE_C(kNameResizeNearestNeighborGrad, ResizeNearestNeighborGrad);
1768 MIND_API_OPERATOR_IMPL(ResizeNearestNeighborGrad, BaseOperator);
1769
set_size(const std::vector<int64_t> & size)1770 void ResizeNearestNeighbor::set_size(const std::vector<int64_t> &size) { (void)this->AddAttr("size", api::MakeValue(size)); }
1771
get_size() const1772 std::vector<int64_t> ResizeNearestNeighbor::get_size() const { return GetValue<std::vector<int64_t>>(GetAttr("size")); }
1773
set_align_corners(const bool & align_corners)1774 void ResizeNearestNeighbor::set_align_corners(const bool &align_corners) { (void)this->AddAttr("align_corners", api::MakeValue(align_corners)); }
1775
get_align_corners() const1776 bool ResizeNearestNeighbor::get_align_corners() const { return GetValue<bool>(GetAttr("align_corners")); }
1777
set_half_pixel_centers(const bool & half_pixel_centers)1778 void ResizeNearestNeighbor::set_half_pixel_centers(const bool &half_pixel_centers) { (void)this->AddAttr("half_pixel_centers", api::MakeValue(half_pixel_centers)); }
1779
get_half_pixel_centers() const1780 bool ResizeNearestNeighbor::get_half_pixel_centers() const { return GetValue<bool>(GetAttr("half_pixel_centers")); }
1781
1782 REGISTER_PRIMITIVE_C(kNameResizeNearestNeighbor, ResizeNearestNeighbor);
1783 MIND_API_OPERATOR_IMPL(ResizeNearestNeighbor, BaseOperator);
1784
set_align_corners(const bool & align_corners)1785 void ResizeNearestNeighborV2Grad::set_align_corners(const bool &align_corners) { (void)this->AddAttr("align_corners", api::MakeValue(align_corners)); }
1786
get_align_corners() const1787 bool ResizeNearestNeighborV2Grad::get_align_corners() const { return GetValue<bool>(GetAttr("align_corners")); }
1788
set_half_pixel_centers(const bool & half_pixel_centers)1789 void ResizeNearestNeighborV2Grad::set_half_pixel_centers(const bool &half_pixel_centers) { (void)this->AddAttr("half_pixel_centers", api::MakeValue(half_pixel_centers)); }
1790
get_half_pixel_centers() const1791 bool ResizeNearestNeighborV2Grad::get_half_pixel_centers() const { return GetValue<bool>(GetAttr("half_pixel_centers")); }
1792
1793 REGISTER_PRIMITIVE_C(kNameResizeNearestNeighborV2Grad, ResizeNearestNeighborV2Grad);
1794 MIND_API_OPERATOR_IMPL(ResizeNearestNeighborV2Grad, BaseOperator);
1795
set_align_corners(const bool & align_corners)1796 void ResizeNearestNeighborV2::set_align_corners(const bool &align_corners) { (void)this->AddAttr("align_corners", api::MakeValue(align_corners)); }
1797
get_align_corners() const1798 bool ResizeNearestNeighborV2::get_align_corners() const { return GetValue<bool>(GetAttr("align_corners")); }
1799
set_half_pixel_centers(const bool & half_pixel_centers)1800 void ResizeNearestNeighborV2::set_half_pixel_centers(const bool &half_pixel_centers) { (void)this->AddAttr("half_pixel_centers", api::MakeValue(half_pixel_centers)); }
1801
get_half_pixel_centers() const1802 bool ResizeNearestNeighborV2::get_half_pixel_centers() const { return GetValue<bool>(GetAttr("half_pixel_centers")); }
1803
1804 REGISTER_PRIMITIVE_C(kNameResizeNearestNeighborV2, ResizeNearestNeighborV2);
1805 MIND_API_OPERATOR_IMPL(ResizeNearestNeighborV2, BaseOperator);
1806
set_axis(const std::vector<int64_t> & axis)1807 void ReverseV2::set_axis(const std::vector<int64_t> &axis) { (void)this->AddAttr("axis", api::MakeValue(axis)); }
1808
get_axis() const1809 std::vector<int64_t> ReverseV2::get_axis() const { return GetValue<std::vector<int64_t>>(GetAttr("axis")); }
1810
1811 REGISTER_PRIMITIVE_C(kNameReverseV2, ReverseV2);
1812 MIND_API_OPERATOR_IMPL(ReverseV2, BaseOperator);
1813
1814 REGISTER_PRIMITIVE_C(kNameRFFTGrad, RFFTGrad);
1815 MIND_API_OPERATOR_IMPL(RFFTGrad, BaseOperator);
1816
1817 REGISTER_PRIMITIVE_C(kNameRFFT, RFFT);
1818 MIND_API_OPERATOR_IMPL(RFFT, BaseOperator);
1819
1820 REGISTER_PRIMITIVE_C(kNameRightShift, RightShift);
1821 MIND_API_OPERATOR_IMPL(RightShift, BaseOperator);
1822
1823 REGISTER_PRIMITIVE_C(kNameRmsNormGrad, RmsNormGrad);
1824 MIND_API_OPERATOR_IMPL(RmsNormGrad, BaseOperator);
1825
set_epsilon(const float & epsilon)1826 void RmsNorm::set_epsilon(const float &epsilon) { (void)this->AddAttr("epsilon", api::MakeValue(epsilon)); }
1827
get_epsilon() const1828 float RmsNorm::get_epsilon() const { return GetValue<float>(GetAttr("epsilon")); }
1829
1830 REGISTER_PRIMITIVE_C(kNameRmsNorm, RmsNorm);
1831 MIND_API_OPERATOR_IMPL(RmsNorm, BaseOperator);
1832
set_shift(const std::vector<int64_t> & shift)1833 void Roll::set_shift(const std::vector<int64_t> &shift) { (void)this->AddAttr("shift", api::MakeValue(shift)); }
1834
get_shift() const1835 std::vector<int64_t> Roll::get_shift() const { return GetValue<std::vector<int64_t>>(GetAttr("shift")); }
1836
set_axis(const std::vector<int64_t> & axis)1837 void Roll::set_axis(const std::vector<int64_t> &axis) { (void)this->AddAttr("axis", api::MakeValue(axis)); }
1838
get_axis() const1839 std::vector<int64_t> Roll::get_axis() const { return GetValue<std::vector<int64_t>>(GetAttr("axis")); }
1840
1841 REGISTER_PRIMITIVE_C(kNameRoll, Roll);
1842 MIND_API_OPERATOR_IMPL(Roll, BaseOperator);
1843
1844 REGISTER_PRIMITIVE_C(kNameRound, Round);
1845 MIND_API_OPERATOR_IMPL(Round, BaseOperator);
1846
1847 REGISTER_PRIMITIVE_C(kNameRsqrtGrad, RsqrtGrad);
1848 MIND_API_OPERATOR_IMPL(RsqrtGrad, BaseOperator);
1849
1850 REGISTER_PRIMITIVE_C(kNameRsqrt, Rsqrt);
1851 MIND_API_OPERATOR_IMPL(Rsqrt, BaseOperator);
1852
1853 REGISTER_PRIMITIVE_C(kNameScalarAdd, ScalarAdd);
1854 MIND_API_OPERATOR_IMPL(ScalarAdd, BaseOperator);
1855
1856 REGISTER_PRIMITIVE_C(kNameScalarBool, ScalarBool);
1857 MIND_API_OPERATOR_IMPL(ScalarBool, BaseOperator);
1858
1859 REGISTER_PRIMITIVE_C(kNameScalarCast, ScalarCast);
1860 MIND_API_OPERATOR_IMPL(ScalarCast, BaseOperator);
1861
1862 REGISTER_PRIMITIVE_C(kNameScalarDiv, ScalarDiv);
1863 MIND_API_OPERATOR_IMPL(ScalarDiv, BaseOperator);
1864
1865 REGISTER_PRIMITIVE_C(kNameScalarEq, ScalarEq);
1866 MIND_API_OPERATOR_IMPL(ScalarEq, BaseOperator);
1867
1868 REGISTER_PRIMITIVE_C(kNameScalarFloorDiv, ScalarFloorDiv);
1869 MIND_API_OPERATOR_IMPL(ScalarFloorDiv, BaseOperator);
1870
1871 REGISTER_PRIMITIVE_C(kNameScalarGe, ScalarGe);
1872 MIND_API_OPERATOR_IMPL(ScalarGe, BaseOperator);
1873
1874 REGISTER_PRIMITIVE_C(kNameScalarGt, ScalarGt);
1875 MIND_API_OPERATOR_IMPL(ScalarGt, BaseOperator);
1876
1877 REGISTER_PRIMITIVE_C(kNameScalarLe, ScalarLe);
1878 MIND_API_OPERATOR_IMPL(ScalarLe, BaseOperator);
1879
1880 REGISTER_PRIMITIVE_C(kNameScalarLog, ScalarLog);
1881 MIND_API_OPERATOR_IMPL(ScalarLog, BaseOperator);
1882
1883 REGISTER_PRIMITIVE_C(kNameScalarLt, ScalarLt);
1884 MIND_API_OPERATOR_IMPL(ScalarLt, BaseOperator);
1885
1886 REGISTER_PRIMITIVE_C(kNameScalarMod, ScalarMod);
1887 MIND_API_OPERATOR_IMPL(ScalarMod, BaseOperator);
1888
1889 REGISTER_PRIMITIVE_C(kNameScalarMul, ScalarMul);
1890 MIND_API_OPERATOR_IMPL(ScalarMul, BaseOperator);
1891
1892 REGISTER_PRIMITIVE_C(kNameScalarPow, ScalarPow);
1893 MIND_API_OPERATOR_IMPL(ScalarPow, BaseOperator);
1894
1895 REGISTER_PRIMITIVE_C(kNameScalarSub, ScalarSub);
1896 MIND_API_OPERATOR_IMPL(ScalarSub, BaseOperator);
1897
1898 REGISTER_PRIMITIVE_C(kNameScalarToTensor, ScalarToTensor);
1899 MIND_API_OPERATOR_IMPL(ScalarToTensor, BaseOperator);
1900
1901 REGISTER_PRIMITIVE_C(kNameScalarUadd, ScalarUadd);
1902 MIND_API_OPERATOR_IMPL(ScalarUadd, BaseOperator);
1903
1904 REGISTER_PRIMITIVE_C(kNameScalarUsub, ScalarUsub);
1905 MIND_API_OPERATOR_IMPL(ScalarUsub, BaseOperator);
1906
1907 REGISTER_PRIMITIVE_C(kNameScatterAddExt, ScatterAddExt);
1908 MIND_API_OPERATOR_IMPL(ScatterAddExt, BaseOperator);
1909
1910 REGISTER_PRIMITIVE_C(kNameScatterNd, ScatterNd);
1911 MIND_API_OPERATOR_IMPL(ScatterNd, BaseOperator);
1912
1913 REGISTER_PRIMITIVE_C(kNameScatter, Scatter);
1914 MIND_API_OPERATOR_IMPL(Scatter, BaseOperator);
1915
set_dtype(const int64_t & dtype)1916 void SearchSorted::set_dtype(const int64_t &dtype) { (void)this->AddAttr("dtype", api::MakeValue(dtype)); }
1917
get_dtype() const1918 int64_t SearchSorted::get_dtype() const { return GetValue<int64_t>(GetAttr("dtype")); }
1919
set_right(const bool & right)1920 void SearchSorted::set_right(const bool &right) { (void)this->AddAttr("right", api::MakeValue(right)); }
1921
get_right() const1922 bool SearchSorted::get_right() const { return GetValue<bool>(GetAttr("right")); }
1923
1924 REGISTER_PRIMITIVE_C(kNameSearchSorted, SearchSorted);
1925 MIND_API_OPERATOR_IMPL(SearchSorted, BaseOperator);
1926
1927 REGISTER_PRIMITIVE_C(kNameSelect, Select);
1928 MIND_API_OPERATOR_IMPL(Select, BaseOperator);
1929
set_axis(const int64_t & axis)1930 void SequenceConcat::set_axis(const int64_t &axis) { (void)this->AddAttr("axis", api::MakeValue(axis)); }
1931
get_axis() const1932 int64_t SequenceConcat::get_axis() const { return GetValue<int64_t>(GetAttr("axis")); }
1933
1934 REGISTER_PRIMITIVE_C(kNameSequenceConcat, SequenceConcat);
1935 MIND_API_OPERATOR_IMPL(SequenceConcat, BaseOperator);
1936
1937 REGISTER_PRIMITIVE_C(kNameShape, Shape);
1938 MIND_API_OPERATOR_IMPL(Shape, BaseOperator);
1939
1940 REGISTER_PRIMITIVE_C(kNameSigmoidGrad, SigmoidGrad);
1941 MIND_API_OPERATOR_IMPL(SigmoidGrad, BaseOperator);
1942
1943 REGISTER_PRIMITIVE_C(kNameSigmoid, Sigmoid);
1944 MIND_API_OPERATOR_IMPL(Sigmoid, BaseOperator);
1945
1946 REGISTER_PRIMITIVE_C(kNameSign, Sign);
1947 MIND_API_OPERATOR_IMPL(Sign, BaseOperator);
1948
1949 REGISTER_PRIMITIVE_C(kNameSiLUGrad, SiLUGrad);
1950 MIND_API_OPERATOR_IMPL(SiLUGrad, BaseOperator);
1951
1952 REGISTER_PRIMITIVE_C(kNameSiLU, SiLU);
1953 MIND_API_OPERATOR_IMPL(SiLU, BaseOperator);
1954
1955 REGISTER_PRIMITIVE_C(kNameSin, Sin);
1956 MIND_API_OPERATOR_IMPL(Sin, BaseOperator);
1957
1958 REGISTER_PRIMITIVE_C(kNameSinc, Sinc);
1959 MIND_API_OPERATOR_IMPL(Sinc, BaseOperator);
1960
1961 REGISTER_PRIMITIVE_C(kNameSinh, Sinh);
1962 MIND_API_OPERATOR_IMPL(Sinh, BaseOperator);
1963
1964 REGISTER_PRIMITIVE_C(kNameSliceExt, SliceExt);
1965 MIND_API_OPERATOR_IMPL(SliceExt, BaseOperator);
1966
1967 REGISTER_PRIMITIVE_C(kNameSoftmaxBackward, SoftmaxBackward);
1968 MIND_API_OPERATOR_IMPL(SoftmaxBackward, BaseOperator);
1969
set_axis(const std::vector<int64_t> & axis)1970 void Softmax::set_axis(const std::vector<int64_t> &axis) { (void)this->AddAttr("axis", api::MakeValue(axis)); }
1971
get_axis() const1972 std::vector<int64_t> Softmax::get_axis() const { return GetValue<std::vector<int64_t>>(GetAttr("axis")); }
1973
1974 REGISTER_PRIMITIVE_C(kNameSoftmax, Softmax);
1975 MIND_API_OPERATOR_IMPL(Softmax, BaseOperator);
1976
1977 REGISTER_PRIMITIVE_C(kNameSoftplusExt, SoftplusExt);
1978 MIND_API_OPERATOR_IMPL(SoftplusExt, BaseOperator);
1979
1980 REGISTER_PRIMITIVE_C(kNameSoftplusGradExt, SoftplusGradExt);
1981 MIND_API_OPERATOR_IMPL(SoftplusGradExt, BaseOperator);
1982
1983 REGISTER_PRIMITIVE_C(kNameSolveTriangular, SolveTriangular);
1984 MIND_API_OPERATOR_IMPL(SolveTriangular, BaseOperator);
1985
1986 REGISTER_PRIMITIVE_C(kNameSortExt, SortExt);
1987 MIND_API_OPERATOR_IMPL(SortExt, BaseOperator);
1988
set_axis(const int64_t & axis)1989 void Split::set_axis(const int64_t &axis) { (void)this->AddAttr("axis", api::MakeValue(axis)); }
1990
get_axis() const1991 int64_t Split::get_axis() const { return GetValue<int64_t>(GetAttr("axis")); }
1992
set_output_num(const int64_t & output_num)1993 void Split::set_output_num(const int64_t &output_num) { (void)this->AddAttr("output_num", api::MakeValue(output_num)); }
1994
get_output_num() const1995 int64_t Split::get_output_num() const { return GetValue<int64_t>(GetAttr("output_num")); }
1996
1997 REGISTER_PRIMITIVE_C(kNameSplit, Split);
1998 MIND_API_OPERATOR_IMPL(Split, BaseOperator);
1999
2000 REGISTER_PRIMITIVE_C(kNameSplitTensor, SplitTensor);
2001 MIND_API_OPERATOR_IMPL(SplitTensor, BaseOperator);
2002
2003 REGISTER_PRIMITIVE_C(kNameSplitWithSize, SplitWithSize);
2004 MIND_API_OPERATOR_IMPL(SplitWithSize, BaseOperator);
2005
2006 REGISTER_PRIMITIVE_C(kNameSqrtGrad, SqrtGrad);
2007 MIND_API_OPERATOR_IMPL(SqrtGrad, BaseOperator);
2008
2009 REGISTER_PRIMITIVE_C(kNameSqrt, Sqrt);
2010 MIND_API_OPERATOR_IMPL(Sqrt, BaseOperator);
2011
2012 REGISTER_PRIMITIVE_C(kNameSquare, Square);
2013 MIND_API_OPERATOR_IMPL(Square, BaseOperator);
2014
set_dim(const int64_t & dim)2015 void StackExt::set_dim(const int64_t &dim) { (void)this->AddAttr("dim", api::MakeValue(dim)); }
2016
get_dim() const2017 int64_t StackExt::get_dim() const { return GetValue<int64_t>(GetAttr("dim")); }
2018
2019 REGISTER_PRIMITIVE_C(kNameStackExt, StackExt);
2020 MIND_API_OPERATOR_IMPL(StackExt, BaseOperator);
2021
set_begin_mask(const int64_t & begin_mask)2022 void StridedSlice::set_begin_mask(const int64_t &begin_mask) { (void)this->AddAttr("begin_mask", api::MakeValue(begin_mask)); }
2023
get_begin_mask() const2024 int64_t StridedSlice::get_begin_mask() const { return GetValue<int64_t>(GetAttr("begin_mask")); }
2025
set_end_mask(const int64_t & end_mask)2026 void StridedSlice::set_end_mask(const int64_t &end_mask) { (void)this->AddAttr("end_mask", api::MakeValue(end_mask)); }
2027
get_end_mask() const2028 int64_t StridedSlice::get_end_mask() const { return GetValue<int64_t>(GetAttr("end_mask")); }
2029
set_ellipsis_mask(const int64_t & ellipsis_mask)2030 void StridedSlice::set_ellipsis_mask(const int64_t &ellipsis_mask) { (void)this->AddAttr("ellipsis_mask", api::MakeValue(ellipsis_mask)); }
2031
get_ellipsis_mask() const2032 int64_t StridedSlice::get_ellipsis_mask() const { return GetValue<int64_t>(GetAttr("ellipsis_mask")); }
2033
set_new_axis_mask(const int64_t & new_axis_mask)2034 void StridedSlice::set_new_axis_mask(const int64_t &new_axis_mask) { (void)this->AddAttr("new_axis_mask", api::MakeValue(new_axis_mask)); }
2035
get_new_axis_mask() const2036 int64_t StridedSlice::get_new_axis_mask() const { return GetValue<int64_t>(GetAttr("new_axis_mask")); }
2037
set_shrink_axis_mask(const int64_t & shrink_axis_mask)2038 void StridedSlice::set_shrink_axis_mask(const int64_t &shrink_axis_mask) { (void)this->AddAttr("shrink_axis_mask", api::MakeValue(shrink_axis_mask)); }
2039
get_shrink_axis_mask() const2040 int64_t StridedSlice::get_shrink_axis_mask() const { return GetValue<int64_t>(GetAttr("shrink_axis_mask")); }
2041
2042 REGISTER_PRIMITIVE_C(kNameStridedSlice, StridedSlice);
2043 MIND_API_OPERATOR_IMPL(StridedSlice, BaseOperator);
2044
2045 REGISTER_PRIMITIVE_C(kNameSubExt, SubExt);
2046 MIND_API_OPERATOR_IMPL(SubExt, BaseOperator);
2047
2048 REGISTER_PRIMITIVE_C(kNameSub, Sub);
2049 MIND_API_OPERATOR_IMPL(Sub, BaseOperator);
2050
2051 REGISTER_PRIMITIVE_C(kNameSumExt, SumExt);
2052 MIND_API_OPERATOR_IMPL(SumExt, BaseOperator);
2053
2054 REGISTER_PRIMITIVE_C(kNameTanhGrad, TanhGrad);
2055 MIND_API_OPERATOR_IMPL(TanhGrad, BaseOperator);
2056
2057 REGISTER_PRIMITIVE_C(kNameTanh, Tanh);
2058 MIND_API_OPERATOR_IMPL(Tanh, BaseOperator);
2059
2060 REGISTER_PRIMITIVE_C(kNameTensorCopySlices, TensorCopySlices);
2061 MIND_API_OPERATOR_IMPL(TensorCopySlices, BaseOperator);
2062
2063 REGISTER_PRIMITIVE_C(kNameTensorShape, TensorShape);
2064 MIND_API_OPERATOR_IMPL(TensorShape, BaseOperator);
2065
2066 REGISTER_PRIMITIVE_C(kNameTile, Tile);
2067 MIND_API_OPERATOR_IMPL(Tile, BaseOperator);
2068
2069 REGISTER_PRIMITIVE_C(kNameTopkExt, TopkExt);
2070 MIND_API_OPERATOR_IMPL(TopkExt, BaseOperator);
2071
2072 REGISTER_PRIMITIVE_C(kNameTopKRouter, TopKRouter);
2073 MIND_API_OPERATOR_IMPL(TopKRouter, BaseOperator);
2074
2075 REGISTER_PRIMITIVE_C(kNameTrace, Trace);
2076 MIND_API_OPERATOR_IMPL(Trace, BaseOperator);
2077
2078 REGISTER_PRIMITIVE_C(kNameTranspose, Transpose);
2079 MIND_API_OPERATOR_IMPL(Transpose, BaseOperator);
2080
set_diagonal(const int64_t & diagonal)2081 void Triu::set_diagonal(const int64_t &diagonal) { (void)this->AddAttr("diagonal", api::MakeValue(diagonal)); }
2082
get_diagonal() const2083 int64_t Triu::get_diagonal() const { return GetValue<int64_t>(GetAttr("diagonal")); }
2084
2085 REGISTER_PRIMITIVE_C(kNameTriu, Triu);
2086 MIND_API_OPERATOR_IMPL(Triu, BaseOperator);
2087
2088 REGISTER_PRIMITIVE_C(kNameTupleToList, TupleToList);
2089 MIND_API_OPERATOR_IMPL(TupleToList, BaseOperator);
2090
2091 REGISTER_PRIMITIVE_C(kNameTupleToTensor, TupleToTensor);
2092 MIND_API_OPERATOR_IMPL(TupleToTensor, BaseOperator);
2093
2094 REGISTER_PRIMITIVE_C(kNameUniformExt, UniformExt);
2095 MIND_API_OPERATOR_IMPL(UniformExt, BaseOperator);
2096
2097 REGISTER_PRIMITIVE_C(kNameUnique2, Unique2);
2098 MIND_API_OPERATOR_IMPL(Unique2, BaseOperator);
2099
2100 REGISTER_PRIMITIVE_C(kNameUniqueDim, UniqueDim);
2101 MIND_API_OPERATOR_IMPL(UniqueDim, BaseOperator);
2102
2103 REGISTER_PRIMITIVE_C(kNameUnsortedSegmentSum, UnsortedSegmentSum);
2104 MIND_API_OPERATOR_IMPL(UnsortedSegmentSum, BaseOperator);
2105
set_axis(const int64_t & axis)2106 void UnstackExt::set_axis(const int64_t &axis) { (void)this->AddAttr("axis", api::MakeValue(axis)); }
2107
get_axis() const2108 int64_t UnstackExt::get_axis() const { return GetValue<int64_t>(GetAttr("axis")); }
2109
2110 REGISTER_PRIMITIVE_C(kNameUnstackExt, UnstackExt);
2111 MIND_API_OPERATOR_IMPL(UnstackExt, BaseOperator);
2112
2113 REGISTER_PRIMITIVE_C(kNameUpsampleBilinear2DGrad, UpsampleBilinear2DGrad);
2114 MIND_API_OPERATOR_IMPL(UpsampleBilinear2DGrad, BaseOperator);
2115
2116 REGISTER_PRIMITIVE_C(kNameUpsampleBilinear2D, UpsampleBilinear2D);
2117 MIND_API_OPERATOR_IMPL(UpsampleBilinear2D, BaseOperator);
2118
2119 REGISTER_PRIMITIVE_C(kNameUpsampleLinear1DGrad, UpsampleLinear1DGrad);
2120 MIND_API_OPERATOR_IMPL(UpsampleLinear1DGrad, BaseOperator);
2121
2122 REGISTER_PRIMITIVE_C(kNameUpsampleLinear1D, UpsampleLinear1D);
2123 MIND_API_OPERATOR_IMPL(UpsampleLinear1D, BaseOperator);
2124
2125 REGISTER_PRIMITIVE_C(kNameUpsampleNearest1DGrad, UpsampleNearest1DGrad);
2126 MIND_API_OPERATOR_IMPL(UpsampleNearest1DGrad, BaseOperator);
2127
2128 REGISTER_PRIMITIVE_C(kNameUpsampleNearest1D, UpsampleNearest1D);
2129 MIND_API_OPERATOR_IMPL(UpsampleNearest1D, BaseOperator);
2130
2131 REGISTER_PRIMITIVE_C(kNameUpsampleNearest2DGrad, UpsampleNearest2DGrad);
2132 MIND_API_OPERATOR_IMPL(UpsampleNearest2DGrad, BaseOperator);
2133
2134 REGISTER_PRIMITIVE_C(kNameUpsampleNearest2D, UpsampleNearest2D);
2135 MIND_API_OPERATOR_IMPL(UpsampleNearest2D, BaseOperator);
2136
2137 REGISTER_PRIMITIVE_C(kNameUpsampleNearest3DGrad, UpsampleNearest3DGrad);
2138 MIND_API_OPERATOR_IMPL(UpsampleNearest3DGrad, BaseOperator);
2139
2140 REGISTER_PRIMITIVE_C(kNameUpsampleNearest3D, UpsampleNearest3D);
2141 MIND_API_OPERATOR_IMPL(UpsampleNearest3D, BaseOperator);
2142
set_align_corners(const bool & align_corners)2143 void UpsampleTrilinear3DGrad::set_align_corners(const bool &align_corners) { (void)this->AddAttr("align_corners", api::MakeValue(align_corners)); }
2144
get_align_corners() const2145 bool UpsampleTrilinear3DGrad::get_align_corners() const { return GetValue<bool>(GetAttr("align_corners")); }
2146
2147 REGISTER_PRIMITIVE_C(kNameUpsampleTrilinear3DGrad, UpsampleTrilinear3DGrad);
2148 MIND_API_OPERATOR_IMPL(UpsampleTrilinear3DGrad, BaseOperator);
2149
set_align_corners(const bool & align_corners)2150 void UpsampleTrilinear3D::set_align_corners(const bool &align_corners) { (void)this->AddAttr("align_corners", api::MakeValue(align_corners)); }
2151
get_align_corners() const2152 bool UpsampleTrilinear3D::get_align_corners() const { return GetValue<bool>(GetAttr("align_corners")); }
2153
2154 REGISTER_PRIMITIVE_C(kNameUpsampleTrilinear3D, UpsampleTrilinear3D);
2155 MIND_API_OPERATOR_IMPL(UpsampleTrilinear3D, BaseOperator);
2156
2157 REGISTER_PRIMITIVE_C(kNameView, View);
2158 MIND_API_OPERATOR_IMPL(View, BaseOperator);
2159
2160 REGISTER_PRIMITIVE_C(kNameZerosLikeExt, ZerosLikeExt);
2161 MIND_API_OPERATOR_IMPL(ZerosLikeExt, BaseOperator);
2162
2163 REGISTER_PRIMITIVE_C(kNameZerosLike, ZerosLike);
2164 MIND_API_OPERATOR_IMPL(ZerosLike, BaseOperator);
2165
2166 REGISTER_PRIMITIVE_C(kNameZeros, Zeros);
2167 MIND_API_OPERATOR_IMPL(Zeros, BaseOperator);
2168
2169 REGISTER_PRIMITIVE_C(kNameDynamicQuantExt, DynamicQuantExt);
2170 MIND_API_OPERATOR_IMPL(DynamicQuantExt, BaseOperator);
2171
set_num_heads(const int64_t & num_heads)2172 void FusedInferAttentionScore::set_num_heads(const int64_t &num_heads) { (void)this->AddAttr("num_heads", api::MakeValue(num_heads)); }
2173
get_num_heads() const2174 int64_t FusedInferAttentionScore::get_num_heads() const { return GetValue<int64_t>(GetAttr("num_heads")); }
2175
set_scale_value(const float & scale_value)2176 void FusedInferAttentionScore::set_scale_value(const float &scale_value) { (void)this->AddAttr("scale_value", api::MakeValue(scale_value)); }
2177
get_scale_value() const2178 float FusedInferAttentionScore::get_scale_value() const { return GetValue<float>(GetAttr("scale_value")); }
2179
set_pre_tokens(const int64_t & pre_tokens)2180 void FusedInferAttentionScore::set_pre_tokens(const int64_t &pre_tokens) { (void)this->AddAttr("pre_tokens", api::MakeValue(pre_tokens)); }
2181
get_pre_tokens() const2182 int64_t FusedInferAttentionScore::get_pre_tokens() const { return GetValue<int64_t>(GetAttr("pre_tokens")); }
2183
set_next_tokens(const int64_t & next_tokens)2184 void FusedInferAttentionScore::set_next_tokens(const int64_t &next_tokens) { (void)this->AddAttr("next_tokens", api::MakeValue(next_tokens)); }
2185
get_next_tokens() const2186 int64_t FusedInferAttentionScore::get_next_tokens() const { return GetValue<int64_t>(GetAttr("next_tokens")); }
2187
set_input_layout(const int64_t & input_layout)2188 void FusedInferAttentionScore::set_input_layout(const int64_t &input_layout) { (void)this->AddAttr("input_layout", api::MakeValue(input_layout)); }
2189
get_input_layout() const2190 int64_t FusedInferAttentionScore::get_input_layout() const { return GetValue<int64_t>(GetAttr("input_layout")); }
2191
set_num_key_value_heads(const int64_t & num_key_value_heads)2192 void FusedInferAttentionScore::set_num_key_value_heads(const int64_t &num_key_value_heads) { (void)this->AddAttr("num_key_value_heads", api::MakeValue(num_key_value_heads)); }
2193
get_num_key_value_heads() const2194 int64_t FusedInferAttentionScore::get_num_key_value_heads() const { return GetValue<int64_t>(GetAttr("num_key_value_heads")); }
2195
set_sparse_mode(const int64_t & sparse_mode)2196 void FusedInferAttentionScore::set_sparse_mode(const int64_t &sparse_mode) { (void)this->AddAttr("sparse_mode", api::MakeValue(sparse_mode)); }
2197
get_sparse_mode() const2198 int64_t FusedInferAttentionScore::get_sparse_mode() const { return GetValue<int64_t>(GetAttr("sparse_mode")); }
2199
set_inner_precise(const int64_t & inner_precise)2200 void FusedInferAttentionScore::set_inner_precise(const int64_t &inner_precise) { (void)this->AddAttr("inner_precise", api::MakeValue(inner_precise)); }
2201
get_inner_precise() const2202 int64_t FusedInferAttentionScore::get_inner_precise() const { return GetValue<int64_t>(GetAttr("inner_precise")); }
2203
set_block_size(const int64_t & block_size)2204 void FusedInferAttentionScore::set_block_size(const int64_t &block_size) { (void)this->AddAttr("block_size", api::MakeValue(block_size)); }
2205
get_block_size() const2206 int64_t FusedInferAttentionScore::get_block_size() const { return GetValue<int64_t>(GetAttr("block_size")); }
2207
set_antiquant_mode(const int64_t & antiquant_mode)2208 void FusedInferAttentionScore::set_antiquant_mode(const int64_t &antiquant_mode) { (void)this->AddAttr("antiquant_mode", api::MakeValue(antiquant_mode)); }
2209
get_antiquant_mode() const2210 int64_t FusedInferAttentionScore::get_antiquant_mode() const { return GetValue<int64_t>(GetAttr("antiquant_mode")); }
2211
set_softmax_lse_flag(const bool & softmax_lse_flag)2212 void FusedInferAttentionScore::set_softmax_lse_flag(const bool &softmax_lse_flag) { (void)this->AddAttr("softmax_lse_flag", api::MakeValue(softmax_lse_flag)); }
2213
get_softmax_lse_flag() const2214 bool FusedInferAttentionScore::get_softmax_lse_flag() const { return GetValue<bool>(GetAttr("softmax_lse_flag")); }
2215
2216 REGISTER_PRIMITIVE_C(kNameFusedInferAttentionScore, FusedInferAttentionScore);
2217 MIND_API_OPERATOR_IMPL(FusedInferAttentionScore, BaseOperator);
2218
set_split_item(const int64_t & split_item)2219 void GroupedMatmul::set_split_item(const int64_t &split_item) { (void)this->AddAttr("split_item", api::MakeValue(split_item)); }
2220
get_split_item() const2221 int64_t GroupedMatmul::get_split_item() const { return GetValue<int64_t>(GetAttr("split_item")); }
2222
set_group_type(const int64_t & group_type)2223 void GroupedMatmul::set_group_type(const int64_t &group_type) { (void)this->AddAttr("group_type", api::MakeValue(group_type)); }
2224
get_group_type() const2225 int64_t GroupedMatmul::get_group_type() const { return GetValue<int64_t>(GetAttr("group_type")); }
2226
2227 REGISTER_PRIMITIVE_C(kNameGroupedMatmul, GroupedMatmul);
2228 MIND_API_OPERATOR_IMPL(GroupedMatmul, BaseOperator);
2229
2230 REGISTER_PRIMITIVE_C(kNameKVCacheScatterUpdate, KVCacheScatterUpdate);
2231 MIND_API_OPERATOR_IMPL(KVCacheScatterUpdate, BaseOperator);
2232
2233 REGISTER_PRIMITIVE_C(kNameMatmulBiasSplitOut2, MatmulBiasSplitOut2);
2234 MIND_API_OPERATOR_IMPL(MatmulBiasSplitOut2, BaseOperator);
2235
2236 REGISTER_PRIMITIVE_C(kNameMatmulBiasSplitOut3, MatmulBiasSplitOut3);
2237 MIND_API_OPERATOR_IMPL(MatmulBiasSplitOut3, BaseOperator);
2238
2239 REGISTER_PRIMITIVE_C(kNameMatmulBiasSplitSiluOut2, MatmulBiasSplitSiluOut2);
2240 MIND_API_OPERATOR_IMPL(MatmulBiasSplitSiluOut2, BaseOperator);
2241
2242 REGISTER_PRIMITIVE_C(kNameMatmulSplitOut2, MatmulSplitOut2);
2243 MIND_API_OPERATOR_IMPL(MatmulSplitOut2, BaseOperator);
2244
2245 REGISTER_PRIMITIVE_C(kNameMatmulSplitOut3, MatmulSplitOut3);
2246 MIND_API_OPERATOR_IMPL(MatmulSplitOut3, BaseOperator);
2247
2248 REGISTER_PRIMITIVE_C(kNameMatmulSplitSiluOut2, MatmulSplitSiluOut2);
2249 MIND_API_OPERATOR_IMPL(MatmulSplitSiluOut2, BaseOperator);
2250
2251 REGISTER_PRIMITIVE_C(kNameMoeFinalizeRouting, MoeFinalizeRouting);
2252 MIND_API_OPERATOR_IMPL(MoeFinalizeRouting, BaseOperator);
2253
set_transpose_x1(const bool & transpose_x1)2254 void QuantBatchMatmul::set_transpose_x1(const bool &transpose_x1) { (void)this->AddAttr("transpose_x1", api::MakeValue(transpose_x1)); }
2255
get_transpose_x1() const2256 bool QuantBatchMatmul::get_transpose_x1() const { return GetValue<bool>(GetAttr("transpose_x1")); }
2257
set_transpose_x2(const bool & transpose_x2)2258 void QuantBatchMatmul::set_transpose_x2(const bool &transpose_x2) { (void)this->AddAttr("transpose_x2", api::MakeValue(transpose_x2)); }
2259
get_transpose_x2() const2260 bool QuantBatchMatmul::get_transpose_x2() const { return GetValue<bool>(GetAttr("transpose_x2")); }
2261
set_dtype(const int64_t & dtype)2262 void QuantBatchMatmul::set_dtype(const int64_t &dtype) { (void)this->AddAttr("dtype", api::MakeValue(dtype)); }
2263
get_dtype() const2264 int64_t QuantBatchMatmul::get_dtype() const { return GetValue<int64_t>(GetAttr("dtype")); }
2265
2266 REGISTER_PRIMITIVE_C(kNameQuantBatchMatmul, QuantBatchMatmul);
2267 MIND_API_OPERATOR_IMPL(QuantBatchMatmul, BaseOperator);
2268
2269 REGISTER_PRIMITIVE_C(kNameQuantV2, QuantV2);
2270 MIND_API_OPERATOR_IMPL(QuantV2, BaseOperator);
2271
2272 REGISTER_PRIMITIVE_C(kNameQuantbatchmatmulSplitOut2, QuantbatchmatmulSplitOut2);
2273 MIND_API_OPERATOR_IMPL(QuantbatchmatmulSplitOut2, BaseOperator);
2274
2275 REGISTER_PRIMITIVE_C(kNameQuantbatchmatmulSplitOut3, QuantbatchmatmulSplitOut3);
2276 MIND_API_OPERATOR_IMPL(QuantbatchmatmulSplitOut3, BaseOperator);
2277
2278 REGISTER_PRIMITIVE_C(kNameQuantbatchmatmulSplitSiluOut2, QuantbatchmatmulSplitSiluOut2);
2279 MIND_API_OPERATOR_IMPL(QuantbatchmatmulSplitSiluOut2, BaseOperator);
2280
set_transpose_x(const bool & transpose_x)2281 void WeightQuantBatchMatmul::set_transpose_x(const bool &transpose_x) { (void)this->AddAttr("transpose_x", api::MakeValue(transpose_x)); }
2282
get_transpose_x() const2283 bool WeightQuantBatchMatmul::get_transpose_x() const { return GetValue<bool>(GetAttr("transpose_x")); }
2284
set_transpose_weight(const bool & transpose_weight)2285 void WeightQuantBatchMatmul::set_transpose_weight(const bool &transpose_weight) { (void)this->AddAttr("transpose_weight", api::MakeValue(transpose_weight)); }
2286
get_transpose_weight() const2287 bool WeightQuantBatchMatmul::get_transpose_weight() const { return GetValue<bool>(GetAttr("transpose_weight")); }
2288
set_antiquant_group_size(const int64_t & antiquant_group_size)2289 void WeightQuantBatchMatmul::set_antiquant_group_size(const int64_t &antiquant_group_size) { (void)this->AddAttr("antiquant_group_size", api::MakeValue(antiquant_group_size)); }
2290
get_antiquant_group_size() const2291 int64_t WeightQuantBatchMatmul::get_antiquant_group_size() const { return GetValue<int64_t>(GetAttr("antiquant_group_size")); }
2292
2293 REGISTER_PRIMITIVE_C(kNameWeightQuantBatchMatmul, WeightQuantBatchMatmul);
2294 MIND_API_OPERATOR_IMPL(WeightQuantBatchMatmul, BaseOperator);
2295
2296 } // namespace mindspore::ops
2297