1 // automatically generated by the FlatBuffers compiler, do not modify
2
3
4 #ifndef FLATBUFFERS_GENERATED_OPSTYPES_MINDSPORE_SCHEMA_H_
5 #define FLATBUFFERS_GENERATED_OPSTYPES_MINDSPORE_SCHEMA_H_
6
7 #include "flatbuffers/flatbuffers.h"
8
9 // Ensure the included flatbuffers.h is the same version as when this file was
10 // generated, otherwise it may not be compatible.
11 static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
12 FLATBUFFERS_VERSION_MINOR == 3 &&
13 FLATBUFFERS_VERSION_REVISION == 25,
14 "Non-compatible flatbuffers version included");
15
16 namespace mindspore {
17 namespace schema {
18
19 struct Vec;
20 struct VecBuilder;
21 struct VecT;
22
23 struct Vec2D;
24 struct Vec2DBuilder;
25 struct Vec2DT;
26
27 struct Attribute;
28 struct AttributeBuilder;
29 struct AttributeT;
30
31 inline const ::flatbuffers::TypeTable *VecTypeTable();
32
33 inline const ::flatbuffers::TypeTable *Vec2DTypeTable();
34
35 inline const ::flatbuffers::TypeTable *AttributeTypeTable();
36
37 enum ResizeMethod : int8_t {
38 ResizeMethod_UNKNOWN = -1,
39 ResizeMethod_LINEAR = 0,
40 ResizeMethod_NEAREST = 1,
41 ResizeMethod_CUBIC = 2,
42 ResizeMethod_MIN = ResizeMethod_UNKNOWN,
43 ResizeMethod_MAX = ResizeMethod_CUBIC
44 };
45
EnumValuesResizeMethod()46 inline const ResizeMethod (&EnumValuesResizeMethod())[4] {
47 static const ResizeMethod values[] = {
48 ResizeMethod_UNKNOWN,
49 ResizeMethod_LINEAR,
50 ResizeMethod_NEAREST,
51 ResizeMethod_CUBIC
52 };
53 return values;
54 }
55
EnumNamesResizeMethod()56 inline const char * const *EnumNamesResizeMethod() {
57 static const char * const names[5] = {
58 "UNKNOWN",
59 "LINEAR",
60 "NEAREST",
61 "CUBIC",
62 nullptr
63 };
64 return names;
65 }
66
EnumNameResizeMethod(ResizeMethod e)67 inline const char *EnumNameResizeMethod(ResizeMethod e) {
68 if (::flatbuffers::IsOutRange(e, ResizeMethod_UNKNOWN, ResizeMethod_CUBIC)) return "";
69 const size_t index = static_cast<size_t>(e) - static_cast<size_t>(ResizeMethod_UNKNOWN);
70 return EnumNamesResizeMethod()[index];
71 }
72
73 enum CoordinateTransformMode : int8_t {
74 CoordinateTransformMode_ASYMMETRIC = 0,
75 CoordinateTransformMode_ALIGN_CORNERS = 1,
76 CoordinateTransformMode_HALF_PIXEL = 2,
77 CoordinateTransformMode_MIN = CoordinateTransformMode_ASYMMETRIC,
78 CoordinateTransformMode_MAX = CoordinateTransformMode_HALF_PIXEL
79 };
80
EnumValuesCoordinateTransformMode()81 inline const CoordinateTransformMode (&EnumValuesCoordinateTransformMode())[3] {
82 static const CoordinateTransformMode values[] = {
83 CoordinateTransformMode_ASYMMETRIC,
84 CoordinateTransformMode_ALIGN_CORNERS,
85 CoordinateTransformMode_HALF_PIXEL
86 };
87 return values;
88 }
89
EnumNamesCoordinateTransformMode()90 inline const char * const *EnumNamesCoordinateTransformMode() {
91 static const char * const names[4] = {
92 "ASYMMETRIC",
93 "ALIGN_CORNERS",
94 "HALF_PIXEL",
95 nullptr
96 };
97 return names;
98 }
99
EnumNameCoordinateTransformMode(CoordinateTransformMode e)100 inline const char *EnumNameCoordinateTransformMode(CoordinateTransformMode e) {
101 if (::flatbuffers::IsOutRange(e, CoordinateTransformMode_ASYMMETRIC, CoordinateTransformMode_HALF_PIXEL)) return "";
102 const size_t index = static_cast<size_t>(e);
103 return EnumNamesCoordinateTransformMode()[index];
104 }
105
106 enum NearestMode : int8_t {
107 NearestMode_NORMAL = 0,
108 NearestMode_ROUND_HALF_DOWN = 1,
109 NearestMode_ROUND_HALF_UP = 2,
110 NearestMode_FLOOR = 3,
111 NearestMode_CEIL = 4,
112 NearestMode_MIN = NearestMode_NORMAL,
113 NearestMode_MAX = NearestMode_CEIL
114 };
115
EnumValuesNearestMode()116 inline const NearestMode (&EnumValuesNearestMode())[5] {
117 static const NearestMode values[] = {
118 NearestMode_NORMAL,
119 NearestMode_ROUND_HALF_DOWN,
120 NearestMode_ROUND_HALF_UP,
121 NearestMode_FLOOR,
122 NearestMode_CEIL
123 };
124 return values;
125 }
126
EnumNamesNearestMode()127 inline const char * const *EnumNamesNearestMode() {
128 static const char * const names[6] = {
129 "NORMAL",
130 "ROUND_HALF_DOWN",
131 "ROUND_HALF_UP",
132 "FLOOR",
133 "CEIL",
134 nullptr
135 };
136 return names;
137 }
138
EnumNameNearestMode(NearestMode e)139 inline const char *EnumNameNearestMode(NearestMode e) {
140 if (::flatbuffers::IsOutRange(e, NearestMode_NORMAL, NearestMode_CEIL)) return "";
141 const size_t index = static_cast<size_t>(e);
142 return EnumNamesNearestMode()[index];
143 }
144
145 enum Format : int32_t {
146 Format_NCHW = 0,
147 Format_NHWC = 1,
148 Format_NHWC4 = 2,
149 Format_HWKC = 3,
150 Format_HWCK = 4,
151 Format_KCHW = 5,
152 Format_CKHW = 6,
153 Format_KHWC = 7,
154 Format_CHWK = 8,
155 Format_HW = 9,
156 Format_HW4 = 10,
157 Format_NC = 11,
158 Format_NC4 = 12,
159 Format_NC4HW4 = 13,
160 Format_NUM_OF_FORMAT = 14,
161 Format_NCDHW = 15,
162 Format_NWC = 16,
163 Format_NCW = 17,
164 Format_NC8HW8 = 18,
165 Format_MIN = Format_NCHW,
166 Format_MAX = Format_NC8HW8
167 };
168
EnumValuesFormat()169 inline const Format (&EnumValuesFormat())[19] {
170 static const Format values[] = {
171 Format_NCHW,
172 Format_NHWC,
173 Format_NHWC4,
174 Format_HWKC,
175 Format_HWCK,
176 Format_KCHW,
177 Format_CKHW,
178 Format_KHWC,
179 Format_CHWK,
180 Format_HW,
181 Format_HW4,
182 Format_NC,
183 Format_NC4,
184 Format_NC4HW4,
185 Format_NUM_OF_FORMAT,
186 Format_NCDHW,
187 Format_NWC,
188 Format_NCW,
189 Format_NC8HW8
190 };
191 return values;
192 }
193
EnumNamesFormat()194 inline const char * const *EnumNamesFormat() {
195 static const char * const names[20] = {
196 "NCHW",
197 "NHWC",
198 "NHWC4",
199 "HWKC",
200 "HWCK",
201 "KCHW",
202 "CKHW",
203 "KHWC",
204 "CHWK",
205 "HW",
206 "HW4",
207 "NC",
208 "NC4",
209 "NC4HW4",
210 "NUM_OF_FORMAT",
211 "NCDHW",
212 "NWC",
213 "NCW",
214 "NC8HW8",
215 nullptr
216 };
217 return names;
218 }
219
EnumNameFormat(Format e)220 inline const char *EnumNameFormat(Format e) {
221 if (::flatbuffers::IsOutRange(e, Format_NCHW, Format_NC8HW8)) return "";
222 const size_t index = static_cast<size_t>(e);
223 return EnumNamesFormat()[index];
224 }
225
226 enum ActivationType : int8_t {
227 ActivationType_NO_ACTIVATION = 0,
228 ActivationType_RELU = 1,
229 ActivationType_SIGMOID = 2,
230 ActivationType_RELU6 = 3,
231 ActivationType_ELU = 4,
232 ActivationType_LEAKY_RELU = 5,
233 ActivationType_ABS = 6,
234 ActivationType_RELU1 = 7,
235 ActivationType_SOFTSIGN = 8,
236 ActivationType_SOFTPLUS = 9,
237 ActivationType_TANH = 10,
238 ActivationType_SELU = 11,
239 ActivationType_HSWISH = 12,
240 ActivationType_HSIGMOID = 13,
241 ActivationType_THRESHOLDRELU = 14,
242 ActivationType_LINEAR = 15,
243 ActivationType_HARD_TANH = 16,
244 ActivationType_SIGN = 17,
245 ActivationType_SWISH = 18,
246 ActivationType_GELU = 19,
247 ActivationType_FAST_GELU = 20,
248 ActivationType_UNKNOWN = 21,
249 ActivationType_MIN = ActivationType_NO_ACTIVATION,
250 ActivationType_MAX = ActivationType_UNKNOWN
251 };
252
EnumValuesActivationType()253 inline const ActivationType (&EnumValuesActivationType())[22] {
254 static const ActivationType values[] = {
255 ActivationType_NO_ACTIVATION,
256 ActivationType_RELU,
257 ActivationType_SIGMOID,
258 ActivationType_RELU6,
259 ActivationType_ELU,
260 ActivationType_LEAKY_RELU,
261 ActivationType_ABS,
262 ActivationType_RELU1,
263 ActivationType_SOFTSIGN,
264 ActivationType_SOFTPLUS,
265 ActivationType_TANH,
266 ActivationType_SELU,
267 ActivationType_HSWISH,
268 ActivationType_HSIGMOID,
269 ActivationType_THRESHOLDRELU,
270 ActivationType_LINEAR,
271 ActivationType_HARD_TANH,
272 ActivationType_SIGN,
273 ActivationType_SWISH,
274 ActivationType_GELU,
275 ActivationType_FAST_GELU,
276 ActivationType_UNKNOWN
277 };
278 return values;
279 }
280
EnumNamesActivationType()281 inline const char * const *EnumNamesActivationType() {
282 static const char * const names[23] = {
283 "NO_ACTIVATION",
284 "RELU",
285 "SIGMOID",
286 "RELU6",
287 "ELU",
288 "LEAKY_RELU",
289 "ABS",
290 "RELU1",
291 "SOFTSIGN",
292 "SOFTPLUS",
293 "TANH",
294 "SELU",
295 "HSWISH",
296 "HSIGMOID",
297 "THRESHOLDRELU",
298 "LINEAR",
299 "HARD_TANH",
300 "SIGN",
301 "SWISH",
302 "GELU",
303 "FAST_GELU",
304 "UNKNOWN",
305 nullptr
306 };
307 return names;
308 }
309
EnumNameActivationType(ActivationType e)310 inline const char *EnumNameActivationType(ActivationType e) {
311 if (::flatbuffers::IsOutRange(e, ActivationType_NO_ACTIVATION, ActivationType_UNKNOWN)) return "";
312 const size_t index = static_cast<size_t>(e);
313 return EnumNamesActivationType()[index];
314 }
315
316 enum ReduceMode : int8_t {
317 ReduceMode_ReduceMean = 0,
318 ReduceMode_ReduceMax = 1,
319 ReduceMode_ReduceMin = 2,
320 ReduceMode_ReduceProd = 3,
321 ReduceMode_ReduceSum = 4,
322 ReduceMode_ReduceSumSquare = 5,
323 ReduceMode_ReduceASum = 6,
324 ReduceMode_ReduceAll = 7,
325 ReduceMode_ReduceL2 = 8,
326 ReduceMode_MIN = ReduceMode_ReduceMean,
327 ReduceMode_MAX = ReduceMode_ReduceL2
328 };
329
EnumValuesReduceMode()330 inline const ReduceMode (&EnumValuesReduceMode())[9] {
331 static const ReduceMode values[] = {
332 ReduceMode_ReduceMean,
333 ReduceMode_ReduceMax,
334 ReduceMode_ReduceMin,
335 ReduceMode_ReduceProd,
336 ReduceMode_ReduceSum,
337 ReduceMode_ReduceSumSquare,
338 ReduceMode_ReduceASum,
339 ReduceMode_ReduceAll,
340 ReduceMode_ReduceL2
341 };
342 return values;
343 }
344
EnumNamesReduceMode()345 inline const char * const *EnumNamesReduceMode() {
346 static const char * const names[10] = {
347 "ReduceMean",
348 "ReduceMax",
349 "ReduceMin",
350 "ReduceProd",
351 "ReduceSum",
352 "ReduceSumSquare",
353 "ReduceASum",
354 "ReduceAll",
355 "ReduceL2",
356 nullptr
357 };
358 return names;
359 }
360
EnumNameReduceMode(ReduceMode e)361 inline const char *EnumNameReduceMode(ReduceMode e) {
362 if (::flatbuffers::IsOutRange(e, ReduceMode_ReduceMean, ReduceMode_ReduceL2)) return "";
363 const size_t index = static_cast<size_t>(e);
364 return EnumNamesReduceMode()[index];
365 }
366
367 enum PoolMode : int8_t {
368 PoolMode_MAX_POOLING = 0,
369 PoolMode_MEAN_POOLING = 1,
370 PoolMode_MIN = PoolMode_MAX_POOLING,
371 PoolMode_MAX = PoolMode_MEAN_POOLING
372 };
373
EnumValuesPoolMode()374 inline const PoolMode (&EnumValuesPoolMode())[2] {
375 static const PoolMode values[] = {
376 PoolMode_MAX_POOLING,
377 PoolMode_MEAN_POOLING
378 };
379 return values;
380 }
381
EnumNamesPoolMode()382 inline const char * const *EnumNamesPoolMode() {
383 static const char * const names[3] = {
384 "MAX_POOLING",
385 "MEAN_POOLING",
386 nullptr
387 };
388 return names;
389 }
390
EnumNamePoolMode(PoolMode e)391 inline const char *EnumNamePoolMode(PoolMode e) {
392 if (::flatbuffers::IsOutRange(e, PoolMode_MAX_POOLING, PoolMode_MEAN_POOLING)) return "";
393 const size_t index = static_cast<size_t>(e);
394 return EnumNamesPoolMode()[index];
395 }
396
397 enum EltwiseMode : int8_t {
398 EltwiseMode_PROD = 0,
399 EltwiseMode_SUM = 1,
400 EltwiseMode_MAXIMUM = 2,
401 EltwiseMode_UNKNOWN = 3,
402 EltwiseMode_MIN = EltwiseMode_PROD,
403 EltwiseMode_MAX = EltwiseMode_UNKNOWN
404 };
405
EnumValuesEltwiseMode()406 inline const EltwiseMode (&EnumValuesEltwiseMode())[4] {
407 static const EltwiseMode values[] = {
408 EltwiseMode_PROD,
409 EltwiseMode_SUM,
410 EltwiseMode_MAXIMUM,
411 EltwiseMode_UNKNOWN
412 };
413 return values;
414 }
415
EnumNamesEltwiseMode()416 inline const char * const *EnumNamesEltwiseMode() {
417 static const char * const names[5] = {
418 "PROD",
419 "SUM",
420 "MAXIMUM",
421 "UNKNOWN",
422 nullptr
423 };
424 return names;
425 }
426
EnumNameEltwiseMode(EltwiseMode e)427 inline const char *EnumNameEltwiseMode(EltwiseMode e) {
428 if (::flatbuffers::IsOutRange(e, EltwiseMode_PROD, EltwiseMode_UNKNOWN)) return "";
429 const size_t index = static_cast<size_t>(e);
430 return EnumNamesEltwiseMode()[index];
431 }
432
433 enum PadMode : int8_t {
434 PadMode_PAD = 0,
435 PadMode_SAME = 1,
436 PadMode_VALID = 2,
437 PadMode_MIN = PadMode_PAD,
438 PadMode_MAX = PadMode_VALID
439 };
440
EnumValuesPadMode()441 inline const PadMode (&EnumValuesPadMode())[3] {
442 static const PadMode values[] = {
443 PadMode_PAD,
444 PadMode_SAME,
445 PadMode_VALID
446 };
447 return values;
448 }
449
EnumNamesPadMode()450 inline const char * const *EnumNamesPadMode() {
451 static const char * const names[4] = {
452 "PAD",
453 "SAME",
454 "VALID",
455 nullptr
456 };
457 return names;
458 }
459
EnumNamePadMode(PadMode e)460 inline const char *EnumNamePadMode(PadMode e) {
461 if (::flatbuffers::IsOutRange(e, PadMode_PAD, PadMode_VALID)) return "";
462 const size_t index = static_cast<size_t>(e);
463 return EnumNamesPadMode()[index];
464 }
465
466 enum RoundMode : int8_t {
467 RoundMode_FLOOR = 0,
468 RoundMode_CEIL = 1,
469 RoundMode_MIN = RoundMode_FLOOR,
470 RoundMode_MAX = RoundMode_CEIL
471 };
472
EnumValuesRoundMode()473 inline const RoundMode (&EnumValuesRoundMode())[2] {
474 static const RoundMode values[] = {
475 RoundMode_FLOOR,
476 RoundMode_CEIL
477 };
478 return values;
479 }
480
EnumNamesRoundMode()481 inline const char * const *EnumNamesRoundMode() {
482 static const char * const names[3] = {
483 "FLOOR",
484 "CEIL",
485 nullptr
486 };
487 return names;
488 }
489
EnumNameRoundMode(RoundMode e)490 inline const char *EnumNameRoundMode(RoundMode e) {
491 if (::flatbuffers::IsOutRange(e, RoundMode_FLOOR, RoundMode_CEIL)) return "";
492 const size_t index = static_cast<size_t>(e);
493 return EnumNamesRoundMode()[index];
494 }
495
496 enum PaddingMode : int8_t {
497 PaddingMode_CONSTANT = 0,
498 PaddingMode_REFLECT = 1,
499 PaddingMode_SYMMETRIC = 2,
500 PaddingMode_MODE_RESERVED = 3,
501 PaddingMode_MIN = PaddingMode_CONSTANT,
502 PaddingMode_MAX = PaddingMode_MODE_RESERVED
503 };
504
EnumValuesPaddingMode()505 inline const PaddingMode (&EnumValuesPaddingMode())[4] {
506 static const PaddingMode values[] = {
507 PaddingMode_CONSTANT,
508 PaddingMode_REFLECT,
509 PaddingMode_SYMMETRIC,
510 PaddingMode_MODE_RESERVED
511 };
512 return values;
513 }
514
EnumNamesPaddingMode()515 inline const char * const *EnumNamesPaddingMode() {
516 static const char * const names[5] = {
517 "CONSTANT",
518 "REFLECT",
519 "SYMMETRIC",
520 "MODE_RESERVED",
521 nullptr
522 };
523 return names;
524 }
525
EnumNamePaddingMode(PaddingMode e)526 inline const char *EnumNamePaddingMode(PaddingMode e) {
527 if (::flatbuffers::IsOutRange(e, PaddingMode_CONSTANT, PaddingMode_MODE_RESERVED)) return "";
528 const size_t index = static_cast<size_t>(e);
529 return EnumNamesPaddingMode()[index];
530 }
531
532 enum LshProjectionType : int8_t {
533 LshProjectionType_UNKNOWN = 0,
534 LshProjectionType_SPARSE = 1,
535 LshProjectionType_DENSE = 2,
536 LshProjectionType_MIN = LshProjectionType_UNKNOWN,
537 LshProjectionType_MAX = LshProjectionType_DENSE
538 };
539
EnumValuesLshProjectionType()540 inline const LshProjectionType (&EnumValuesLshProjectionType())[3] {
541 static const LshProjectionType values[] = {
542 LshProjectionType_UNKNOWN,
543 LshProjectionType_SPARSE,
544 LshProjectionType_DENSE
545 };
546 return values;
547 }
548
EnumNamesLshProjectionType()549 inline const char * const *EnumNamesLshProjectionType() {
550 static const char * const names[4] = {
551 "UNKNOWN",
552 "SPARSE",
553 "DENSE",
554 nullptr
555 };
556 return names;
557 }
558
EnumNameLshProjectionType(LshProjectionType e)559 inline const char *EnumNameLshProjectionType(LshProjectionType e) {
560 if (::flatbuffers::IsOutRange(e, LshProjectionType_UNKNOWN, LshProjectionType_DENSE)) return "";
561 const size_t index = static_cast<size_t>(e);
562 return EnumNamesLshProjectionType()[index];
563 }
564
565 enum Reduction : int8_t {
566 Reduction_REDUCTION_SUM = 0,
567 Reduction_MEAN = 1,
568 Reduction_NONE = 2,
569 Reduction_MIN = Reduction_REDUCTION_SUM,
570 Reduction_MAX = Reduction_NONE
571 };
572
EnumValuesReduction()573 inline const Reduction (&EnumValuesReduction())[3] {
574 static const Reduction values[] = {
575 Reduction_REDUCTION_SUM,
576 Reduction_MEAN,
577 Reduction_NONE
578 };
579 return values;
580 }
581
EnumNamesReduction()582 inline const char * const *EnumNamesReduction() {
583 static const char * const names[4] = {
584 "REDUCTION_SUM",
585 "MEAN",
586 "NONE",
587 nullptr
588 };
589 return names;
590 }
591
EnumNameReduction(Reduction e)592 inline const char *EnumNameReduction(Reduction e) {
593 if (::flatbuffers::IsOutRange(e, Reduction_REDUCTION_SUM, Reduction_NONE)) return "";
594 const size_t index = static_cast<size_t>(e);
595 return EnumNamesReduction()[index];
596 }
597
598 struct VecT : public ::flatbuffers::NativeTable {
599 typedef Vec TableType;
600 std::vector<int64_t> data{};
601 };
602
603 struct Vec FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
604 typedef VecT NativeTableType;
605 typedef VecBuilder Builder;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS606 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
607 return VecTypeTable();
608 }
609 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
610 VT_DATA = 4
611 };
dataFLATBUFFERS_FINAL_CLASS612 const ::flatbuffers::Vector<int64_t> *data() const {
613 return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_DATA);
614 }
mutable_dataFLATBUFFERS_FINAL_CLASS615 ::flatbuffers::Vector<int64_t> *mutable_data() {
616 return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_DATA);
617 }
VerifyFLATBUFFERS_FINAL_CLASS618 bool Verify(::flatbuffers::Verifier &verifier) const {
619 return VerifyTableStart(verifier) &&
620 VerifyOffset(verifier, VT_DATA) &&
621 verifier.VerifyVector(data()) &&
622 verifier.EndTable();
623 }
624 VecT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
625 void UnPackTo(VecT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
626 static ::flatbuffers::Offset<Vec> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const VecT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
627 };
628
629 struct VecBuilder {
630 typedef Vec Table;
631 ::flatbuffers::FlatBufferBuilder &fbb_;
632 ::flatbuffers::uoffset_t start_;
add_dataVecBuilder633 void add_data(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> data) {
634 fbb_.AddOffset(Vec::VT_DATA, data);
635 }
VecBuilderVecBuilder636 explicit VecBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
637 : fbb_(_fbb) {
638 start_ = fbb_.StartTable();
639 }
FinishVecBuilder640 ::flatbuffers::Offset<Vec> Finish() {
641 const auto end = fbb_.EndTable(start_);
642 auto o = ::flatbuffers::Offset<Vec>(end);
643 return o;
644 }
645 };
646
647 inline ::flatbuffers::Offset<Vec> CreateVec(
648 ::flatbuffers::FlatBufferBuilder &_fbb,
649 ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> data = 0) {
650 VecBuilder builder_(_fbb);
651 builder_.add_data(data);
652 return builder_.Finish();
653 }
654
655 inline ::flatbuffers::Offset<Vec> CreateVecDirect(
656 ::flatbuffers::FlatBufferBuilder &_fbb,
657 const std::vector<int64_t> *data = nullptr) {
658 auto data__ = data ? _fbb.CreateVector<int64_t>(*data) : 0;
659 return mindspore::schema::CreateVec(
660 _fbb,
661 data__);
662 }
663
664 ::flatbuffers::Offset<Vec> CreateVec(::flatbuffers::FlatBufferBuilder &_fbb, const VecT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
665
666 struct Vec2DT : public ::flatbuffers::NativeTable {
667 typedef Vec2D TableType;
668 std::vector<std::unique_ptr<mindspore::schema::VecT>> data{};
669 Vec2DT() = default;
670 Vec2DT(const Vec2DT &o);
671 Vec2DT(Vec2DT&&) FLATBUFFERS_NOEXCEPT = default;
672 Vec2DT &operator=(Vec2DT o) FLATBUFFERS_NOEXCEPT;
673 };
674
675 struct Vec2D FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
676 typedef Vec2DT NativeTableType;
677 typedef Vec2DBuilder Builder;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS678 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
679 return Vec2DTypeTable();
680 }
681 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
682 VT_DATA = 4
683 };
dataFLATBUFFERS_FINAL_CLASS684 const ::flatbuffers::Vector<::flatbuffers::Offset<mindspore::schema::Vec>> *data() const {
685 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<mindspore::schema::Vec>> *>(VT_DATA);
686 }
mutable_dataFLATBUFFERS_FINAL_CLASS687 ::flatbuffers::Vector<::flatbuffers::Offset<mindspore::schema::Vec>> *mutable_data() {
688 return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<mindspore::schema::Vec>> *>(VT_DATA);
689 }
VerifyFLATBUFFERS_FINAL_CLASS690 bool Verify(::flatbuffers::Verifier &verifier) const {
691 return VerifyTableStart(verifier) &&
692 VerifyOffset(verifier, VT_DATA) &&
693 verifier.VerifyVector(data()) &&
694 verifier.VerifyVectorOfTables(data()) &&
695 verifier.EndTable();
696 }
697 Vec2DT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
698 void UnPackTo(Vec2DT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
699 static ::flatbuffers::Offset<Vec2D> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Vec2DT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
700 };
701
702 struct Vec2DBuilder {
703 typedef Vec2D Table;
704 ::flatbuffers::FlatBufferBuilder &fbb_;
705 ::flatbuffers::uoffset_t start_;
add_dataVec2DBuilder706 void add_data(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<mindspore::schema::Vec>>> data) {
707 fbb_.AddOffset(Vec2D::VT_DATA, data);
708 }
Vec2DBuilderVec2DBuilder709 explicit Vec2DBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
710 : fbb_(_fbb) {
711 start_ = fbb_.StartTable();
712 }
FinishVec2DBuilder713 ::flatbuffers::Offset<Vec2D> Finish() {
714 const auto end = fbb_.EndTable(start_);
715 auto o = ::flatbuffers::Offset<Vec2D>(end);
716 return o;
717 }
718 };
719
720 inline ::flatbuffers::Offset<Vec2D> CreateVec2D(
721 ::flatbuffers::FlatBufferBuilder &_fbb,
722 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<mindspore::schema::Vec>>> data = 0) {
723 Vec2DBuilder builder_(_fbb);
724 builder_.add_data(data);
725 return builder_.Finish();
726 }
727
728 inline ::flatbuffers::Offset<Vec2D> CreateVec2DDirect(
729 ::flatbuffers::FlatBufferBuilder &_fbb,
730 const std::vector<::flatbuffers::Offset<mindspore::schema::Vec>> *data = nullptr) {
731 auto data__ = data ? _fbb.CreateVector<::flatbuffers::Offset<mindspore::schema::Vec>>(*data) : 0;
732 return mindspore::schema::CreateVec2D(
733 _fbb,
734 data__);
735 }
736
737 ::flatbuffers::Offset<Vec2D> CreateVec2D(::flatbuffers::FlatBufferBuilder &_fbb, const Vec2DT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
738
739 struct AttributeT : public ::flatbuffers::NativeTable {
740 typedef Attribute TableType;
741 std::string name{};
742 std::vector<uint8_t> data{};
743 };
744
745 struct Attribute FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
746 typedef AttributeT NativeTableType;
747 typedef AttributeBuilder Builder;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS748 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
749 return AttributeTypeTable();
750 }
751 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
752 VT_NAME = 4,
753 VT_DATA = 6
754 };
nameFLATBUFFERS_FINAL_CLASS755 const ::flatbuffers::String *name() const {
756 return GetPointer<const ::flatbuffers::String *>(VT_NAME);
757 }
mutable_nameFLATBUFFERS_FINAL_CLASS758 ::flatbuffers::String *mutable_name() {
759 return GetPointer<::flatbuffers::String *>(VT_NAME);
760 }
dataFLATBUFFERS_FINAL_CLASS761 const ::flatbuffers::Vector<uint8_t> *data() const {
762 return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
763 }
mutable_dataFLATBUFFERS_FINAL_CLASS764 ::flatbuffers::Vector<uint8_t> *mutable_data() {
765 return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_DATA);
766 }
VerifyFLATBUFFERS_FINAL_CLASS767 bool Verify(::flatbuffers::Verifier &verifier) const {
768 return VerifyTableStart(verifier) &&
769 VerifyOffset(verifier, VT_NAME) &&
770 verifier.VerifyString(name()) &&
771 VerifyOffset(verifier, VT_DATA) &&
772 verifier.VerifyVector(data()) &&
773 verifier.EndTable();
774 }
775 AttributeT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
776 void UnPackTo(AttributeT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
777 static ::flatbuffers::Offset<Attribute> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AttributeT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
778 };
779
780 struct AttributeBuilder {
781 typedef Attribute Table;
782 ::flatbuffers::FlatBufferBuilder &fbb_;
783 ::flatbuffers::uoffset_t start_;
add_nameAttributeBuilder784 void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
785 fbb_.AddOffset(Attribute::VT_NAME, name);
786 }
add_dataAttributeBuilder787 void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
788 fbb_.AddOffset(Attribute::VT_DATA, data);
789 }
AttributeBuilderAttributeBuilder790 explicit AttributeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
791 : fbb_(_fbb) {
792 start_ = fbb_.StartTable();
793 }
FinishAttributeBuilder794 ::flatbuffers::Offset<Attribute> Finish() {
795 const auto end = fbb_.EndTable(start_);
796 auto o = ::flatbuffers::Offset<Attribute>(end);
797 return o;
798 }
799 };
800
801 inline ::flatbuffers::Offset<Attribute> CreateAttribute(
802 ::flatbuffers::FlatBufferBuilder &_fbb,
803 ::flatbuffers::Offset<::flatbuffers::String> name = 0,
804 ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
805 AttributeBuilder builder_(_fbb);
806 builder_.add_data(data);
807 builder_.add_name(name);
808 return builder_.Finish();
809 }
810
811 inline ::flatbuffers::Offset<Attribute> CreateAttributeDirect(
812 ::flatbuffers::FlatBufferBuilder &_fbb,
813 const char *name = nullptr,
814 const std::vector<uint8_t> *data = nullptr) {
815 auto name__ = name ? _fbb.CreateString(name) : 0;
816 auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
817 return mindspore::schema::CreateAttribute(
818 _fbb,
819 name__,
820 data__);
821 }
822
823 ::flatbuffers::Offset<Attribute> CreateAttribute(::flatbuffers::FlatBufferBuilder &_fbb, const AttributeT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
824
UnPack(const::flatbuffers::resolver_function_t * _resolver)825 inline VecT *Vec::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
826 auto _o = std::unique_ptr<VecT>(new VecT());
827 UnPackTo(_o.get(), _resolver);
828 return _o.release();
829 }
830
UnPackTo(VecT * _o,const::flatbuffers::resolver_function_t * _resolver)831 inline void Vec::UnPackTo(VecT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
832 (void)_o;
833 (void)_resolver;
834 { auto _e = data(); if (_e) { _o->data.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->data[_i] = _e->Get(_i); } } else { _o->data.resize(0); } }
835 }
836
Pack(::flatbuffers::FlatBufferBuilder & _fbb,const VecT * _o,const::flatbuffers::rehasher_function_t * _rehasher)837 inline ::flatbuffers::Offset<Vec> Vec::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const VecT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
838 return CreateVec(_fbb, _o, _rehasher);
839 }
840
CreateVec(::flatbuffers::FlatBufferBuilder & _fbb,const VecT * _o,const::flatbuffers::rehasher_function_t * _rehasher)841 inline ::flatbuffers::Offset<Vec> CreateVec(::flatbuffers::FlatBufferBuilder &_fbb, const VecT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
842 (void)_rehasher;
843 (void)_o;
844 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const VecT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
845 auto _data = _o->data.size() ? _fbb.CreateVector(_o->data) : 0;
846 return mindspore::schema::CreateVec(
847 _fbb,
848 _data);
849 }
850
Vec2DT(const Vec2DT & o)851 inline Vec2DT::Vec2DT(const Vec2DT &o) {
852 data.reserve(o.data.size());
853 for (const auto &data_ : o.data) { data.emplace_back((data_) ? new mindspore::schema::VecT(*data_) : nullptr); }
854 }
855
856 inline Vec2DT &Vec2DT::operator=(Vec2DT o) FLATBUFFERS_NOEXCEPT {
857 std::swap(data, o.data);
858 return *this;
859 }
860
UnPack(const::flatbuffers::resolver_function_t * _resolver)861 inline Vec2DT *Vec2D::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
862 auto _o = std::unique_ptr<Vec2DT>(new Vec2DT());
863 UnPackTo(_o.get(), _resolver);
864 return _o.release();
865 }
866
UnPackTo(Vec2DT * _o,const::flatbuffers::resolver_function_t * _resolver)867 inline void Vec2D::UnPackTo(Vec2DT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
868 (void)_o;
869 (void)_resolver;
870 { auto _e = data(); if (_e) { _o->data.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->data[_i]) { _e->Get(_i)->UnPackTo(_o->data[_i].get(), _resolver); } else { _o->data[_i] = std::unique_ptr<mindspore::schema::VecT>(_e->Get(_i)->UnPack(_resolver)); }; } } else { _o->data.resize(0); } }
871 }
872
Pack(::flatbuffers::FlatBufferBuilder & _fbb,const Vec2DT * _o,const::flatbuffers::rehasher_function_t * _rehasher)873 inline ::flatbuffers::Offset<Vec2D> Vec2D::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Vec2DT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
874 return CreateVec2D(_fbb, _o, _rehasher);
875 }
876
CreateVec2D(::flatbuffers::FlatBufferBuilder & _fbb,const Vec2DT * _o,const::flatbuffers::rehasher_function_t * _rehasher)877 inline ::flatbuffers::Offset<Vec2D> CreateVec2D(::flatbuffers::FlatBufferBuilder &_fbb, const Vec2DT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
878 (void)_rehasher;
879 (void)_o;
880 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const Vec2DT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
881 auto _data = _o->data.size() ? _fbb.CreateVector<::flatbuffers::Offset<mindspore::schema::Vec>> (_o->data.size(), [](size_t i, _VectorArgs *__va) { return CreateVec(*__va->__fbb, __va->__o->data[i].get(), __va->__rehasher); }, &_va ) : 0;
882 return mindspore::schema::CreateVec2D(
883 _fbb,
884 _data);
885 }
886
UnPack(const::flatbuffers::resolver_function_t * _resolver)887 inline AttributeT *Attribute::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
888 auto _o = std::unique_ptr<AttributeT>(new AttributeT());
889 UnPackTo(_o.get(), _resolver);
890 return _o.release();
891 }
892
UnPackTo(AttributeT * _o,const::flatbuffers::resolver_function_t * _resolver)893 inline void Attribute::UnPackTo(AttributeT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
894 (void)_o;
895 (void)_resolver;
896 { auto _e = name(); if (_e) _o->name = _e->str(); }
897 { auto _e = data(); if (_e) { _o->data.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->data.begin()); } }
898 }
899
Pack(::flatbuffers::FlatBufferBuilder & _fbb,const AttributeT * _o,const::flatbuffers::rehasher_function_t * _rehasher)900 inline ::flatbuffers::Offset<Attribute> Attribute::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AttributeT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
901 return CreateAttribute(_fbb, _o, _rehasher);
902 }
903
CreateAttribute(::flatbuffers::FlatBufferBuilder & _fbb,const AttributeT * _o,const::flatbuffers::rehasher_function_t * _rehasher)904 inline ::flatbuffers::Offset<Attribute> CreateAttribute(::flatbuffers::FlatBufferBuilder &_fbb, const AttributeT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
905 (void)_rehasher;
906 (void)_o;
907 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const AttributeT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
908 auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
909 auto _data = _o->data.size() ? _fbb.CreateVector(_o->data) : 0;
910 return mindspore::schema::CreateAttribute(
911 _fbb,
912 _name,
913 _data);
914 }
915
ResizeMethodTypeTable()916 inline const ::flatbuffers::TypeTable *ResizeMethodTypeTable() {
917 static const ::flatbuffers::TypeCode type_codes[] = {
918 { ::flatbuffers::ET_CHAR, 0, 0 },
919 { ::flatbuffers::ET_CHAR, 0, 0 },
920 { ::flatbuffers::ET_CHAR, 0, 0 },
921 { ::flatbuffers::ET_CHAR, 0, 0 }
922 };
923 static const ::flatbuffers::TypeFunction type_refs[] = {
924 mindspore::schema::ResizeMethodTypeTable
925 };
926 static const int64_t values[] = { -1, 0, 1, 2 };
927 static const char * const names[] = {
928 "UNKNOWN",
929 "LINEAR",
930 "NEAREST",
931 "CUBIC"
932 };
933 static const ::flatbuffers::TypeTable tt = {
934 ::flatbuffers::ST_ENUM, 4, type_codes, type_refs, nullptr, values, names
935 };
936 return &tt;
937 }
938
CoordinateTransformModeTypeTable()939 inline const ::flatbuffers::TypeTable *CoordinateTransformModeTypeTable() {
940 static const ::flatbuffers::TypeCode type_codes[] = {
941 { ::flatbuffers::ET_CHAR, 0, 0 },
942 { ::flatbuffers::ET_CHAR, 0, 0 },
943 { ::flatbuffers::ET_CHAR, 0, 0 }
944 };
945 static const ::flatbuffers::TypeFunction type_refs[] = {
946 mindspore::schema::CoordinateTransformModeTypeTable
947 };
948 static const char * const names[] = {
949 "ASYMMETRIC",
950 "ALIGN_CORNERS",
951 "HALF_PIXEL"
952 };
953 static const ::flatbuffers::TypeTable tt = {
954 ::flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names
955 };
956 return &tt;
957 }
958
NearestModeTypeTable()959 inline const ::flatbuffers::TypeTable *NearestModeTypeTable() {
960 static const ::flatbuffers::TypeCode type_codes[] = {
961 { ::flatbuffers::ET_CHAR, 0, 0 },
962 { ::flatbuffers::ET_CHAR, 0, 0 },
963 { ::flatbuffers::ET_CHAR, 0, 0 },
964 { ::flatbuffers::ET_CHAR, 0, 0 },
965 { ::flatbuffers::ET_CHAR, 0, 0 }
966 };
967 static const ::flatbuffers::TypeFunction type_refs[] = {
968 mindspore::schema::NearestModeTypeTable
969 };
970 static const char * const names[] = {
971 "NORMAL",
972 "ROUND_HALF_DOWN",
973 "ROUND_HALF_UP",
974 "FLOOR",
975 "CEIL"
976 };
977 static const ::flatbuffers::TypeTable tt = {
978 ::flatbuffers::ST_ENUM, 5, type_codes, type_refs, nullptr, nullptr, names
979 };
980 return &tt;
981 }
982
FormatTypeTable()983 inline const ::flatbuffers::TypeTable *FormatTypeTable() {
984 static const ::flatbuffers::TypeCode type_codes[] = {
985 { ::flatbuffers::ET_INT, 0, 0 },
986 { ::flatbuffers::ET_INT, 0, 0 },
987 { ::flatbuffers::ET_INT, 0, 0 },
988 { ::flatbuffers::ET_INT, 0, 0 },
989 { ::flatbuffers::ET_INT, 0, 0 },
990 { ::flatbuffers::ET_INT, 0, 0 },
991 { ::flatbuffers::ET_INT, 0, 0 },
992 { ::flatbuffers::ET_INT, 0, 0 },
993 { ::flatbuffers::ET_INT, 0, 0 },
994 { ::flatbuffers::ET_INT, 0, 0 },
995 { ::flatbuffers::ET_INT, 0, 0 },
996 { ::flatbuffers::ET_INT, 0, 0 },
997 { ::flatbuffers::ET_INT, 0, 0 },
998 { ::flatbuffers::ET_INT, 0, 0 },
999 { ::flatbuffers::ET_INT, 0, 0 },
1000 { ::flatbuffers::ET_INT, 0, 0 },
1001 { ::flatbuffers::ET_INT, 0, 0 },
1002 { ::flatbuffers::ET_INT, 0, 0 },
1003 { ::flatbuffers::ET_INT, 0, 0 }
1004 };
1005 static const ::flatbuffers::TypeFunction type_refs[] = {
1006 mindspore::schema::FormatTypeTable
1007 };
1008 static const char * const names[] = {
1009 "NCHW",
1010 "NHWC",
1011 "NHWC4",
1012 "HWKC",
1013 "HWCK",
1014 "KCHW",
1015 "CKHW",
1016 "KHWC",
1017 "CHWK",
1018 "HW",
1019 "HW4",
1020 "NC",
1021 "NC4",
1022 "NC4HW4",
1023 "NUM_OF_FORMAT",
1024 "NCDHW",
1025 "NWC",
1026 "NCW",
1027 "NC8HW8"
1028 };
1029 static const ::flatbuffers::TypeTable tt = {
1030 ::flatbuffers::ST_ENUM, 19, type_codes, type_refs, nullptr, nullptr, names
1031 };
1032 return &tt;
1033 }
1034
ActivationTypeTypeTable()1035 inline const ::flatbuffers::TypeTable *ActivationTypeTypeTable() {
1036 static const ::flatbuffers::TypeCode type_codes[] = {
1037 { ::flatbuffers::ET_CHAR, 0, 0 },
1038 { ::flatbuffers::ET_CHAR, 0, 0 },
1039 { ::flatbuffers::ET_CHAR, 0, 0 },
1040 { ::flatbuffers::ET_CHAR, 0, 0 },
1041 { ::flatbuffers::ET_CHAR, 0, 0 },
1042 { ::flatbuffers::ET_CHAR, 0, 0 },
1043 { ::flatbuffers::ET_CHAR, 0, 0 },
1044 { ::flatbuffers::ET_CHAR, 0, 0 },
1045 { ::flatbuffers::ET_CHAR, 0, 0 },
1046 { ::flatbuffers::ET_CHAR, 0, 0 },
1047 { ::flatbuffers::ET_CHAR, 0, 0 },
1048 { ::flatbuffers::ET_CHAR, 0, 0 },
1049 { ::flatbuffers::ET_CHAR, 0, 0 },
1050 { ::flatbuffers::ET_CHAR, 0, 0 },
1051 { ::flatbuffers::ET_CHAR, 0, 0 },
1052 { ::flatbuffers::ET_CHAR, 0, 0 },
1053 { ::flatbuffers::ET_CHAR, 0, 0 },
1054 { ::flatbuffers::ET_CHAR, 0, 0 },
1055 { ::flatbuffers::ET_CHAR, 0, 0 },
1056 { ::flatbuffers::ET_CHAR, 0, 0 },
1057 { ::flatbuffers::ET_CHAR, 0, 0 },
1058 { ::flatbuffers::ET_CHAR, 0, 0 }
1059 };
1060 static const ::flatbuffers::TypeFunction type_refs[] = {
1061 mindspore::schema::ActivationTypeTypeTable
1062 };
1063 static const char * const names[] = {
1064 "NO_ACTIVATION",
1065 "RELU",
1066 "SIGMOID",
1067 "RELU6",
1068 "ELU",
1069 "LEAKY_RELU",
1070 "ABS",
1071 "RELU1",
1072 "SOFTSIGN",
1073 "SOFTPLUS",
1074 "TANH",
1075 "SELU",
1076 "HSWISH",
1077 "HSIGMOID",
1078 "THRESHOLDRELU",
1079 "LINEAR",
1080 "HARD_TANH",
1081 "SIGN",
1082 "SWISH",
1083 "GELU",
1084 "FAST_GELU",
1085 "UNKNOWN"
1086 };
1087 static const ::flatbuffers::TypeTable tt = {
1088 ::flatbuffers::ST_ENUM, 22, type_codes, type_refs, nullptr, nullptr, names
1089 };
1090 return &tt;
1091 }
1092
ReduceModeTypeTable()1093 inline const ::flatbuffers::TypeTable *ReduceModeTypeTable() {
1094 static const ::flatbuffers::TypeCode type_codes[] = {
1095 { ::flatbuffers::ET_CHAR, 0, 0 },
1096 { ::flatbuffers::ET_CHAR, 0, 0 },
1097 { ::flatbuffers::ET_CHAR, 0, 0 },
1098 { ::flatbuffers::ET_CHAR, 0, 0 },
1099 { ::flatbuffers::ET_CHAR, 0, 0 },
1100 { ::flatbuffers::ET_CHAR, 0, 0 },
1101 { ::flatbuffers::ET_CHAR, 0, 0 },
1102 { ::flatbuffers::ET_CHAR, 0, 0 },
1103 { ::flatbuffers::ET_CHAR, 0, 0 }
1104 };
1105 static const ::flatbuffers::TypeFunction type_refs[] = {
1106 mindspore::schema::ReduceModeTypeTable
1107 };
1108 static const char * const names[] = {
1109 "ReduceMean",
1110 "ReduceMax",
1111 "ReduceMin",
1112 "ReduceProd",
1113 "ReduceSum",
1114 "ReduceSumSquare",
1115 "ReduceASum",
1116 "ReduceAll",
1117 "ReduceL2"
1118 };
1119 static const ::flatbuffers::TypeTable tt = {
1120 ::flatbuffers::ST_ENUM, 9, type_codes, type_refs, nullptr, nullptr, names
1121 };
1122 return &tt;
1123 }
1124
PoolModeTypeTable()1125 inline const ::flatbuffers::TypeTable *PoolModeTypeTable() {
1126 static const ::flatbuffers::TypeCode type_codes[] = {
1127 { ::flatbuffers::ET_CHAR, 0, 0 },
1128 { ::flatbuffers::ET_CHAR, 0, 0 }
1129 };
1130 static const ::flatbuffers::TypeFunction type_refs[] = {
1131 mindspore::schema::PoolModeTypeTable
1132 };
1133 static const char * const names[] = {
1134 "MAX_POOLING",
1135 "MEAN_POOLING"
1136 };
1137 static const ::flatbuffers::TypeTable tt = {
1138 ::flatbuffers::ST_ENUM, 2, type_codes, type_refs, nullptr, nullptr, names
1139 };
1140 return &tt;
1141 }
1142
EltwiseModeTypeTable()1143 inline const ::flatbuffers::TypeTable *EltwiseModeTypeTable() {
1144 static const ::flatbuffers::TypeCode type_codes[] = {
1145 { ::flatbuffers::ET_CHAR, 0, 0 },
1146 { ::flatbuffers::ET_CHAR, 0, 0 },
1147 { ::flatbuffers::ET_CHAR, 0, 0 },
1148 { ::flatbuffers::ET_CHAR, 0, 0 }
1149 };
1150 static const ::flatbuffers::TypeFunction type_refs[] = {
1151 mindspore::schema::EltwiseModeTypeTable
1152 };
1153 static const char * const names[] = {
1154 "PROD",
1155 "SUM",
1156 "MAXIMUM",
1157 "UNKNOWN"
1158 };
1159 static const ::flatbuffers::TypeTable tt = {
1160 ::flatbuffers::ST_ENUM, 4, type_codes, type_refs, nullptr, nullptr, names
1161 };
1162 return &tt;
1163 }
1164
PadModeTypeTable()1165 inline const ::flatbuffers::TypeTable *PadModeTypeTable() {
1166 static const ::flatbuffers::TypeCode type_codes[] = {
1167 { ::flatbuffers::ET_CHAR, 0, 0 },
1168 { ::flatbuffers::ET_CHAR, 0, 0 },
1169 { ::flatbuffers::ET_CHAR, 0, 0 }
1170 };
1171 static const ::flatbuffers::TypeFunction type_refs[] = {
1172 mindspore::schema::PadModeTypeTable
1173 };
1174 static const char * const names[] = {
1175 "PAD",
1176 "SAME",
1177 "VALID"
1178 };
1179 static const ::flatbuffers::TypeTable tt = {
1180 ::flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names
1181 };
1182 return &tt;
1183 }
1184
RoundModeTypeTable()1185 inline const ::flatbuffers::TypeTable *RoundModeTypeTable() {
1186 static const ::flatbuffers::TypeCode type_codes[] = {
1187 { ::flatbuffers::ET_CHAR, 0, 0 },
1188 { ::flatbuffers::ET_CHAR, 0, 0 }
1189 };
1190 static const ::flatbuffers::TypeFunction type_refs[] = {
1191 mindspore::schema::RoundModeTypeTable
1192 };
1193 static const char * const names[] = {
1194 "FLOOR",
1195 "CEIL"
1196 };
1197 static const ::flatbuffers::TypeTable tt = {
1198 ::flatbuffers::ST_ENUM, 2, type_codes, type_refs, nullptr, nullptr, names
1199 };
1200 return &tt;
1201 }
1202
PaddingModeTypeTable()1203 inline const ::flatbuffers::TypeTable *PaddingModeTypeTable() {
1204 static const ::flatbuffers::TypeCode type_codes[] = {
1205 { ::flatbuffers::ET_CHAR, 0, 0 },
1206 { ::flatbuffers::ET_CHAR, 0, 0 },
1207 { ::flatbuffers::ET_CHAR, 0, 0 },
1208 { ::flatbuffers::ET_CHAR, 0, 0 }
1209 };
1210 static const ::flatbuffers::TypeFunction type_refs[] = {
1211 mindspore::schema::PaddingModeTypeTable
1212 };
1213 static const char * const names[] = {
1214 "CONSTANT",
1215 "REFLECT",
1216 "SYMMETRIC",
1217 "MODE_RESERVED"
1218 };
1219 static const ::flatbuffers::TypeTable tt = {
1220 ::flatbuffers::ST_ENUM, 4, type_codes, type_refs, nullptr, nullptr, names
1221 };
1222 return &tt;
1223 }
1224
LshProjectionTypeTypeTable()1225 inline const ::flatbuffers::TypeTable *LshProjectionTypeTypeTable() {
1226 static const ::flatbuffers::TypeCode type_codes[] = {
1227 { ::flatbuffers::ET_CHAR, 0, 0 },
1228 { ::flatbuffers::ET_CHAR, 0, 0 },
1229 { ::flatbuffers::ET_CHAR, 0, 0 }
1230 };
1231 static const ::flatbuffers::TypeFunction type_refs[] = {
1232 mindspore::schema::LshProjectionTypeTypeTable
1233 };
1234 static const char * const names[] = {
1235 "UNKNOWN",
1236 "SPARSE",
1237 "DENSE"
1238 };
1239 static const ::flatbuffers::TypeTable tt = {
1240 ::flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names
1241 };
1242 return &tt;
1243 }
1244
ReductionTypeTable()1245 inline const ::flatbuffers::TypeTable *ReductionTypeTable() {
1246 static const ::flatbuffers::TypeCode type_codes[] = {
1247 { ::flatbuffers::ET_CHAR, 0, 0 },
1248 { ::flatbuffers::ET_CHAR, 0, 0 },
1249 { ::flatbuffers::ET_CHAR, 0, 0 }
1250 };
1251 static const ::flatbuffers::TypeFunction type_refs[] = {
1252 mindspore::schema::ReductionTypeTable
1253 };
1254 static const char * const names[] = {
1255 "REDUCTION_SUM",
1256 "MEAN",
1257 "NONE"
1258 };
1259 static const ::flatbuffers::TypeTable tt = {
1260 ::flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names
1261 };
1262 return &tt;
1263 }
1264
VecTypeTable()1265 inline const ::flatbuffers::TypeTable *VecTypeTable() {
1266 static const ::flatbuffers::TypeCode type_codes[] = {
1267 { ::flatbuffers::ET_LONG, 1, -1 }
1268 };
1269 static const char * const names[] = {
1270 "data"
1271 };
1272 static const ::flatbuffers::TypeTable tt = {
1273 ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
1274 };
1275 return &tt;
1276 }
1277
Vec2DTypeTable()1278 inline const ::flatbuffers::TypeTable *Vec2DTypeTable() {
1279 static const ::flatbuffers::TypeCode type_codes[] = {
1280 { ::flatbuffers::ET_SEQUENCE, 1, 0 }
1281 };
1282 static const ::flatbuffers::TypeFunction type_refs[] = {
1283 mindspore::schema::VecTypeTable
1284 };
1285 static const char * const names[] = {
1286 "data"
1287 };
1288 static const ::flatbuffers::TypeTable tt = {
1289 ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
1290 };
1291 return &tt;
1292 }
1293
AttributeTypeTable()1294 inline const ::flatbuffers::TypeTable *AttributeTypeTable() {
1295 static const ::flatbuffers::TypeCode type_codes[] = {
1296 { ::flatbuffers::ET_STRING, 0, -1 },
1297 { ::flatbuffers::ET_UCHAR, 1, -1 }
1298 };
1299 static const char * const names[] = {
1300 "name",
1301 "data"
1302 };
1303 static const ::flatbuffers::TypeTable tt = {
1304 ::flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names
1305 };
1306 return &tt;
1307 }
1308
1309 } // namespace schema
1310 } // namespace mindspore
1311
1312 #endif // FLATBUFFERS_GENERATED_OPSTYPES_MINDSPORE_SCHEMA_H_
1313