1 // automatically generated by the FlatBuffers compiler, do not modify
2
3
4 #ifndef FLATBUFFERS_GENERATED_OPSV0_MINDSPORE_SCHEMA_V0_H_
5 #define FLATBUFFERS_GENERATED_OPSV0_MINDSPORE_SCHEMA_V0_H_
6
7 #include "flatbuffers/flatbuffers.h"
8
9 namespace mindspore {
10 namespace schema {
11 namespace v0 {
12
13 struct Pad;
14 struct PadBuilder;
15 struct PadT;
16
17 struct Maximum;
18 struct MaximumBuilder;
19 struct MaximumT;
20
21 struct Minimum;
22 struct MinimumBuilder;
23 struct MinimumT;
24
25 struct Flatten;
26 struct FlattenBuilder;
27 struct FlattenT;
28
29 struct FlattenGrad;
30 struct FlattenGradBuilder;
31 struct FlattenGradT;
32
33 struct Concat;
34 struct ConcatBuilder;
35 struct ConcatT;
36
37 struct SoftMax;
38 struct SoftMaxBuilder;
39 struct SoftMaxT;
40
41 struct Activation;
42 struct ActivationBuilder;
43 struct ActivationT;
44
45 struct ActivationGrad;
46 struct ActivationGradBuilder;
47 struct ActivationGradT;
48
49 struct Conv2D;
50 struct Conv2DBuilder;
51 struct Conv2DT;
52
53 struct Adder;
54 struct AdderBuilder;
55 struct AdderT;
56
57 struct Conv2DGradFilter;
58 struct Conv2DGradFilterBuilder;
59 struct Conv2DGradFilterT;
60
61 struct Conv2DGradInput;
62 struct Conv2DGradInputBuilder;
63 struct Conv2DGradInputT;
64
65 struct GroupConv2DGradInput;
66 struct GroupConv2DGradInputBuilder;
67 struct GroupConv2DGradInputT;
68
69 struct FusedBatchNorm;
70 struct FusedBatchNormBuilder;
71 struct FusedBatchNormT;
72
73 struct BatchNorm;
74 struct BatchNormBuilder;
75 struct BatchNormT;
76
77 struct BiasGrad;
78 struct BiasGradBuilder;
79 struct BiasGradT;
80
81 struct SoftmaxCrossEntropy;
82 struct SoftmaxCrossEntropyBuilder;
83 struct SoftmaxCrossEntropyT;
84
85 struct SparseSoftmaxCrossEntropy;
86 struct SparseSoftmaxCrossEntropyBuilder;
87 struct SparseSoftmaxCrossEntropyT;
88
89 struct make_tuple;
90 struct make_tupleBuilder;
91 struct make_tupleT;
92
93 struct PoolingGrad;
94 struct PoolingGradBuilder;
95 struct PoolingGradT;
96
97 struct Shape;
98 struct ShapeBuilder;
99 struct ShapeT;
100
101 struct ConstantOfShape;
102 struct ConstantOfShapeBuilder;
103 struct ConstantOfShapeT;
104
105 struct Nchw2Nhwc;
106 struct Nchw2NhwcBuilder;
107 struct Nchw2NhwcT;
108
109 struct Nhwc2Nchw;
110 struct Nhwc2NchwBuilder;
111 struct Nhwc2NchwT;
112
113 struct FakeQuantWithMinMaxVars;
114 struct FakeQuantWithMinMaxVarsBuilder;
115 struct FakeQuantWithMinMaxVarsT;
116
117 struct BiasAdd;
118 struct BiasAddBuilder;
119 struct BiasAddT;
120
121 struct ROIPooling;
122 struct ROIPoolingBuilder;
123 struct ROIPoolingT;
124
125 struct Pooling;
126 struct PoolingBuilder;
127 struct PoolingT;
128
129 struct DepthwiseConv2D;
130 struct DepthwiseConv2DBuilder;
131 struct DepthwiseConv2DT;
132
133 struct DeDepthwiseConv2D;
134 struct DeDepthwiseConv2DBuilder;
135 struct DeDepthwiseConv2DT;
136
137 struct Resize;
138 struct ResizeBuilder;
139 struct ResizeT;
140
141 struct DetectionPostProcess;
142 struct DetectionPostProcessBuilder;
143 struct DetectionPostProcessT;
144
145 struct FullConnection;
146 struct FullConnectionBuilder;
147 struct FullConnectionT;
148
149 struct Mean;
150 struct MeanBuilder;
151 struct MeanT;
152
153 struct DeConv2D;
154 struct DeConv2DBuilder;
155 struct DeConv2DT;
156
157 struct DeConv2DGradFilter;
158 struct DeConv2DGradFilterBuilder;
159 struct DeConv2DGradFilterT;
160
161 struct BNGrad;
162 struct BNGradBuilder;
163 struct BNGradT;
164
165 struct Scale;
166 struct ScaleBuilder;
167 struct ScaleT;
168
169 struct Eltwise;
170 struct EltwiseBuilder;
171 struct EltwiseT;
172
173 struct Add;
174 struct AddBuilder;
175 struct AddT;
176
177 struct Sub;
178 struct SubBuilder;
179 struct SubT;
180
181 struct Mul;
182 struct MulBuilder;
183 struct MulT;
184
185 struct Div;
186 struct DivBuilder;
187 struct DivT;
188
189 struct AddGrad;
190 struct AddGradBuilder;
191 struct AddGradT;
192
193 struct SubGrad;
194 struct SubGradBuilder;
195 struct SubGradT;
196
197 struct MulGrad;
198 struct MulGradBuilder;
199 struct MulGradT;
200
201 struct DivGrad;
202 struct DivGradBuilder;
203 struct DivGradT;
204
205 struct RealDiv;
206 struct RealDivBuilder;
207 struct RealDivT;
208
209 struct Rsqrt;
210 struct RsqrtBuilder;
211 struct RsqrtT;
212
213 struct Equal;
214 struct EqualBuilder;
215 struct EqualT;
216
217 struct Less;
218 struct LessBuilder;
219 struct LessT;
220
221 struct Greater;
222 struct GreaterBuilder;
223 struct GreaterT;
224
225 struct NotEqual;
226 struct NotEqualBuilder;
227 struct NotEqualT;
228
229 struct LessEqual;
230 struct LessEqualBuilder;
231 struct LessEqualT;
232
233 struct GreaterEqual;
234 struct GreaterEqualBuilder;
235 struct GreaterEqualT;
236
237 struct Min;
238 struct MinBuilder;
239 struct MinT;
240
241 struct Slice;
242 struct SliceBuilder;
243 struct SliceT;
244
245 struct Floor;
246 struct FloorBuilder;
247 struct FloorT;
248
249 struct Abs;
250 struct AbsBuilder;
251 struct AbsT;
252
253 struct Neg;
254 struct NegBuilder;
255 struct NegT;
256
257 struct NegGrad;
258 struct NegGradBuilder;
259 struct NegGradT;
260
261 struct Exp;
262 struct ExpBuilder;
263 struct ExpT;
264
265 struct Cos;
266 struct CosBuilder;
267 struct CosT;
268
269 struct Sin;
270 struct SinBuilder;
271 struct SinT;
272
273 struct Sqrt;
274 struct SqrtBuilder;
275 struct SqrtT;
276
277 struct Square;
278 struct SquareBuilder;
279 struct SquareT;
280
281 struct Ceil;
282 struct CeilBuilder;
283 struct CeilT;
284
285 struct Log;
286 struct LogBuilder;
287 struct LogT;
288
289 struct LogGrad;
290 struct LogGradBuilder;
291 struct LogGradT;
292
293 struct Tan;
294 struct TanBuilder;
295 struct TanT;
296
297 struct Atan;
298 struct AtanBuilder;
299 struct AtanT;
300
301 struct Asin;
302 struct AsinBuilder;
303 struct AsinT;
304
305 struct Reshape;
306 struct ReshapeBuilder;
307 struct ReshapeT;
308
309 struct Power;
310 struct PowerBuilder;
311 struct PowerT;
312
313 struct PowerGrad;
314 struct PowerGradBuilder;
315 struct PowerGradT;
316
317 struct ArgMax;
318 struct ArgMaxBuilder;
319 struct ArgMaxT;
320
321 struct ArgMin;
322 struct ArgMinBuilder;
323 struct ArgMinT;
324
325 struct NetOutput;
326 struct NetOutputBuilder;
327 struct NetOutputT;
328
329 struct MatMul;
330 struct MatMulBuilder;
331 struct MatMulT;
332
333 struct PReLU;
334 struct PReLUBuilder;
335 struct PReLUT;
336
337 struct LeakyReLU;
338 struct LeakyReLUBuilder;
339 struct LeakyReLUT;
340
341 struct StridedSlice;
342 struct StridedSliceBuilder;
343 struct StridedSliceT;
344
345 struct Stack;
346 struct StackBuilder;
347 struct StackT;
348
349 struct Range;
350 struct RangeBuilder;
351 struct RangeT;
352
353 struct ExpandDims;
354 struct ExpandDimsBuilder;
355 struct ExpandDimsT;
356
357 struct Tile;
358 struct TileBuilder;
359 struct TileT;
360
361 struct Cast;
362 struct CastBuilder;
363 struct CastT;
364
365 struct QuantDTypeCast;
366 struct QuantDTypeCastBuilder;
367 struct QuantDTypeCastT;
368
369 struct Split;
370 struct SplitBuilder;
371 struct SplitT;
372
373 struct Crop;
374 struct CropBuilder;
375 struct CropT;
376
377 struct Permute;
378 struct PermuteBuilder;
379 struct PermuteT;
380
381 struct Clip;
382 struct ClipBuilder;
383 struct ClipT;
384
385 struct Constant;
386 struct ConstantBuilder;
387 struct ConstantT;
388
389 struct Elu;
390 struct EluBuilder;
391 struct EluT;
392
393 struct Broadcast;
394 struct BroadcastBuilder;
395 struct BroadcastT;
396
397 struct BroadcastTo;
398 struct BroadcastToBuilder;
399 struct BroadcastToT;
400
401 struct Lrn;
402 struct LrnBuilder;
403 struct LrnT;
404
405 struct Reduce;
406 struct ReduceBuilder;
407 struct ReduceT;
408
409 struct Transpose;
410 struct TransposeBuilder;
411 struct TransposeT;
412
413 struct Squeeze;
414 struct SqueezeBuilder;
415 struct SqueezeT;
416
417 struct Unsqueeze;
418 struct UnsqueezeBuilder;
419 struct UnsqueezeT;
420
421 struct Upsample;
422 struct UpsampleBuilder;
423 struct UpsampleT;
424
425 struct Dropout;
426 struct DropoutBuilder;
427 struct DropoutT;
428
429 struct LocalResponseNormalization;
430 struct LocalResponseNormalizationBuilder;
431 struct LocalResponseNormalizationT;
432
433 struct ZerosLike;
434 struct ZerosLikeBuilder;
435 struct ZerosLikeT;
436
437 struct TopK;
438 struct TopKBuilder;
439 struct TopKT;
440
441 struct SpaceToDepth;
442 struct SpaceToDepthBuilder;
443 struct SpaceToDepthT;
444
445 struct SpaceToBatch;
446 struct SpaceToBatchBuilder;
447 struct SpaceToBatchT;
448
449 struct SparseToDense;
450 struct SparseToDenseBuilder;
451 struct SparseToDenseT;
452
453 struct ReverseSequence;
454 struct ReverseSequenceBuilder;
455 struct ReverseSequenceT;
456
457 struct Rank;
458 struct RankBuilder;
459 struct RankT;
460
461 struct Gather;
462 struct GatherBuilder;
463 struct GatherT;
464
465 struct GatherNd;
466 struct GatherNdBuilder;
467 struct GatherNdT;
468
469 struct Fill;
470 struct FillBuilder;
471 struct FillT;
472
473 struct DepthToSpace;
474 struct DepthToSpaceBuilder;
475 struct DepthToSpaceT;
476
477 struct BatchToSpace;
478 struct BatchToSpaceBuilder;
479 struct BatchToSpaceT;
480
481 struct BatchToSpaceND;
482 struct BatchToSpaceNDBuilder;
483 struct BatchToSpaceNDT;
484
485 struct AddN;
486 struct AddNBuilder;
487 struct AddNT;
488
489 struct EmbeddingLookup;
490 struct EmbeddingLookupBuilder;
491 struct EmbeddingLookupT;
492
493 struct EmbeddingLookupSparse;
494 struct EmbeddingLookupSparseBuilder;
495 struct EmbeddingLookupSparseT;
496
497 struct FloorDiv;
498 struct FloorDivBuilder;
499 struct FloorDivT;
500
501 struct FloorMod;
502 struct FloorModBuilder;
503 struct FloorModT;
504
505 struct Mod;
506 struct ModBuilder;
507 struct ModT;
508
509 struct L2Norm;
510 struct L2NormBuilder;
511 struct L2NormT;
512
513 struct LogicalAnd;
514 struct LogicalAndBuilder;
515 struct LogicalAndT;
516
517 struct LogicalOr;
518 struct LogicalOrBuilder;
519 struct LogicalOrT;
520
521 struct LogicalXor;
522 struct LogicalXorBuilder;
523 struct LogicalXorT;
524
525 struct LogicalNot;
526 struct LogicalNotBuilder;
527 struct LogicalNotT;
528
529 struct MatrixDiag;
530 struct MatrixDiagBuilder;
531 struct MatrixDiagT;
532
533 struct Select;
534 struct SelectBuilder;
535 struct SelectT;
536
537 struct TfReduce;
538 struct TfReduceBuilder;
539 struct TfReduceT;
540
541 struct Reverse;
542 struct ReverseBuilder;
543 struct ReverseT;
544
545 struct Round;
546 struct RoundBuilder;
547 struct RoundT;
548
549 struct Scatter;
550 struct ScatterBuilder;
551 struct ScatterT;
552
553 struct ScatterND;
554 struct ScatterNDBuilder;
555 struct ScatterNDT;
556
557 struct Unique;
558 struct UniqueBuilder;
559 struct UniqueT;
560
561 struct Unstack;
562 struct UnstackBuilder;
563 struct UnstackT;
564
565 struct OnnxInt8Quantize;
566 struct OnnxInt8QuantizeBuilder;
567 struct OnnxInt8QuantizeT;
568
569 struct OnnxInt8Dequantize;
570 struct OnnxInt8DequantizeBuilder;
571 struct OnnxInt8DequantizeT;
572
573 struct FakeQuantWithMinMax;
574 struct FakeQuantWithMinMaxBuilder;
575 struct FakeQuantWithMinMaxT;
576
577 struct FakeQuantWithMinMaxPerChannel;
578 struct FakeQuantWithMinMaxPerChannelBuilder;
579 struct FakeQuantWithMinMaxPerChannelT;
580
581 struct BatchNormFold;
582 struct BatchNormFoldBuilder;
583 struct BatchNormFoldT;
584
585 struct MulFold;
586 struct MulFoldBuilder;
587 struct MulFoldT;
588
589 struct AddFold;
590 struct AddFoldBuilder;
591 struct AddFoldT;
592
593 struct SquaredDifference;
594 struct SquaredDifferenceBuilder;
595 struct SquaredDifferenceT;
596
597 struct TupleGetItem;
598 struct TupleGetItemBuilder;
599 struct TupleGetItemT;
600
601 struct ApplyMomentum;
602 struct ApplyMomentumBuilder;
603 struct ApplyMomentumT;
604
605 struct Sgd;
606 struct SgdBuilder;
607 struct SgdT;
608
609 struct Adam;
610 struct AdamBuilder;
611 struct AdamT;
612
613 struct Assign;
614 struct AssignBuilder;
615 struct AssignT;
616
617 struct AssignAdd;
618 struct AssignAddBuilder;
619 struct AssignAddT;
620
621 struct Where;
622 struct WhereBuilder;
623 struct WhereT;
624
625 struct OneHot;
626 struct OneHotBuilder;
627 struct OneHotT;
628
629 struct Lstm;
630 struct LstmBuilder;
631 struct LstmT;
632
633 struct PriorBox;
634 struct PriorBoxBuilder;
635 struct PriorBoxT;
636
637 struct SpaceToBatchND;
638 struct SpaceToBatchNDBuilder;
639 struct SpaceToBatchNDT;
640
641 struct MakeTuple;
642 struct MakeTupleBuilder;
643 struct MakeTupleT;
644
645 struct ToFormat;
646 struct ToFormatBuilder;
647 struct ToFormatT;
648
649 struct Depend;
650 struct DependBuilder;
651 struct DependT;
652
653 struct ControlDepend;
654 struct ControlDependBuilder;
655 struct ControlDependT;
656
657 struct Return;
658 struct ReturnBuilder;
659 struct ReturnT;
660
661 struct Proposal;
662 struct ProposalBuilder;
663 struct ProposalT;
664
665 struct Custom;
666 struct CustomBuilder;
667 struct CustomT;
668
669 struct BlackBox;
670 struct BlackBoxBuilder;
671 struct BlackBoxT;
672
673 struct LshProjection;
674 struct LshProjectionBuilder;
675 struct LshProjectionT;
676
677 struct HashtableLookup;
678 struct HashtableLookupBuilder;
679 struct HashtableLookupT;
680
681 struct SkipGram;
682 struct SkipGramBuilder;
683 struct SkipGramT;
684
685 struct CustomPredict;
686 struct CustomPredictBuilder;
687 struct CustomPredictT;
688
689 struct CustomNormalize;
690 struct CustomNormalizeBuilder;
691 struct CustomNormalizeT;
692
693 struct CustomExtractFeatures;
694 struct CustomExtractFeaturesBuilder;
695 struct CustomExtractFeaturesT;
696
697 struct AudioSpectrogram;
698 struct AudioSpectrogramBuilder;
699 struct AudioSpectrogramT;
700
701 struct Mfcc;
702 struct MfccBuilder;
703 struct MfccT;
704
705 struct Rfft;
706 struct RfftBuilder;
707 struct RfftT;
708
709 struct FftReal;
710 struct FftRealBuilder;
711 struct FftRealT;
712
713 struct FftImag;
714 struct FftImagBuilder;
715 struct FftImagT;
716
717 struct DropoutGrad;
718 struct DropoutGradBuilder;
719 struct DropoutGradT;
720
721 struct MaximumGrad;
722 struct MaximumGradBuilder;
723 struct MaximumGradT;
724
725 struct MinimumGrad;
726 struct MinimumGradBuilder;
727 struct MinimumGradT;
728
729 struct NonMaxSuppression;
730 struct NonMaxSuppressionBuilder;
731 struct NonMaxSuppressionT;
732
733 struct InstanceNorm;
734 struct InstanceNormBuilder;
735 struct InstanceNormT;
736
737 struct Loop;
738 struct LoopBuilder;
739 struct LoopT;
740
741 struct Identity;
742 struct IdentityBuilder;
743 struct IdentityT;
744
745 struct LayerNorm;
746 struct LayerNormBuilder;
747 struct LayerNormT;
748
749 struct While;
750 struct WhileBuilder;
751 struct WhileT;
752
753 struct UnsortedSegmentSum;
754 struct UnsortedSegmentSumBuilder;
755 struct UnsortedSegmentSumT;
756
757 struct OnesLike;
758 struct OnesLikeBuilder;
759 struct OnesLikeT;
760
761 struct BinaryCrossEntropy;
762 struct BinaryCrossEntropyBuilder;
763 struct BinaryCrossEntropyT;
764
765 struct BinaryCrossEntropyGrad;
766 struct BinaryCrossEntropyGradBuilder;
767 struct BinaryCrossEntropyGradT;
768
769 struct LpNormalization;
770 struct LpNormalizationBuilder;
771 struct LpNormalizationT;
772
773 struct Switch;
774 struct SwitchBuilder;
775 struct SwitchT;
776
777 struct Partial;
778 struct PartialBuilder;
779 struct PartialT;
780
781 struct TensorListFromTensor;
782 struct TensorListFromTensorBuilder;
783 struct TensorListFromTensorT;
784
785 struct TensorListStack;
786 struct TensorListStackBuilder;
787 struct TensorListStackT;
788
789 struct TensorListGetItem;
790 struct TensorListGetItemBuilder;
791 struct TensorListGetItemT;
792
793 struct TensorListSetItem;
794 struct TensorListSetItemBuilder;
795 struct TensorListSetItemT;
796
797 struct TensorListReserve;
798 struct TensorListReserveBuilder;
799 struct TensorListReserveT;
800
801 struct All;
802 struct AllBuilder;
803 struct AllT;
804
805 struct Assert;
806 struct AssertBuilder;
807 struct AssertT;
808
809 struct SmoothL1Loss;
810 struct SmoothL1LossBuilder;
811 struct SmoothL1LossT;
812
813 struct SmoothL1LossGrad;
814 struct SmoothL1LossGradBuilder;
815 struct SmoothL1LossGradT;
816
817 struct SigmoidCrossEntropyWithLogits;
818 struct SigmoidCrossEntropyWithLogitsBuilder;
819 struct SigmoidCrossEntropyWithLogitsT;
820
821 struct SigmoidCrossEntropyWithLogitsGrad;
822 struct SigmoidCrossEntropyWithLogitsGradBuilder;
823 struct SigmoidCrossEntropyWithLogitsGradT;
824
825 struct Reciprocal;
826 struct ReciprocalBuilder;
827 struct ReciprocalT;
828
829 struct Merge;
830 struct MergeBuilder;
831 struct MergeT;
832
833 struct GeLU;
834 struct GeLUBuilder;
835 struct GeLUT;
836
837 inline const flatbuffers::TypeTable *PadTypeTable();
838
839 inline const flatbuffers::TypeTable *MaximumTypeTable();
840
841 inline const flatbuffers::TypeTable *MinimumTypeTable();
842
843 inline const flatbuffers::TypeTable *FlattenTypeTable();
844
845 inline const flatbuffers::TypeTable *FlattenGradTypeTable();
846
847 inline const flatbuffers::TypeTable *ConcatTypeTable();
848
849 inline const flatbuffers::TypeTable *SoftMaxTypeTable();
850
851 inline const flatbuffers::TypeTable *ActivationTypeTable();
852
853 inline const flatbuffers::TypeTable *ActivationGradTypeTable();
854
855 inline const flatbuffers::TypeTable *Conv2DTypeTable();
856
857 inline const flatbuffers::TypeTable *AdderTypeTable();
858
859 inline const flatbuffers::TypeTable *Conv2DGradFilterTypeTable();
860
861 inline const flatbuffers::TypeTable *Conv2DGradInputTypeTable();
862
863 inline const flatbuffers::TypeTable *GroupConv2DGradInputTypeTable();
864
865 inline const flatbuffers::TypeTable *FusedBatchNormTypeTable();
866
867 inline const flatbuffers::TypeTable *BatchNormTypeTable();
868
869 inline const flatbuffers::TypeTable *BiasGradTypeTable();
870
871 inline const flatbuffers::TypeTable *SoftmaxCrossEntropyTypeTable();
872
873 inline const flatbuffers::TypeTable *SparseSoftmaxCrossEntropyTypeTable();
874
875 inline const flatbuffers::TypeTable *make_tupleTypeTable();
876
877 inline const flatbuffers::TypeTable *PoolingGradTypeTable();
878
879 inline const flatbuffers::TypeTable *ShapeTypeTable();
880
881 inline const flatbuffers::TypeTable *ConstantOfShapeTypeTable();
882
883 inline const flatbuffers::TypeTable *Nchw2NhwcTypeTable();
884
885 inline const flatbuffers::TypeTable *Nhwc2NchwTypeTable();
886
887 inline const flatbuffers::TypeTable *FakeQuantWithMinMaxVarsTypeTable();
888
889 inline const flatbuffers::TypeTable *BiasAddTypeTable();
890
891 inline const flatbuffers::TypeTable *ROIPoolingTypeTable();
892
893 inline const flatbuffers::TypeTable *PoolingTypeTable();
894
895 inline const flatbuffers::TypeTable *DepthwiseConv2DTypeTable();
896
897 inline const flatbuffers::TypeTable *DeDepthwiseConv2DTypeTable();
898
899 inline const flatbuffers::TypeTable *ResizeTypeTable();
900
901 inline const flatbuffers::TypeTable *DetectionPostProcessTypeTable();
902
903 inline const flatbuffers::TypeTable *FullConnectionTypeTable();
904
905 inline const flatbuffers::TypeTable *MeanTypeTable();
906
907 inline const flatbuffers::TypeTable *DeConv2DTypeTable();
908
909 inline const flatbuffers::TypeTable *DeConv2DGradFilterTypeTable();
910
911 inline const flatbuffers::TypeTable *BNGradTypeTable();
912
913 inline const flatbuffers::TypeTable *ScaleTypeTable();
914
915 inline const flatbuffers::TypeTable *EltwiseTypeTable();
916
917 inline const flatbuffers::TypeTable *AddTypeTable();
918
919 inline const flatbuffers::TypeTable *SubTypeTable();
920
921 inline const flatbuffers::TypeTable *MulTypeTable();
922
923 inline const flatbuffers::TypeTable *DivTypeTable();
924
925 inline const flatbuffers::TypeTable *AddGradTypeTable();
926
927 inline const flatbuffers::TypeTable *SubGradTypeTable();
928
929 inline const flatbuffers::TypeTable *MulGradTypeTable();
930
931 inline const flatbuffers::TypeTable *DivGradTypeTable();
932
933 inline const flatbuffers::TypeTable *RealDivTypeTable();
934
935 inline const flatbuffers::TypeTable *RsqrtTypeTable();
936
937 inline const flatbuffers::TypeTable *EqualTypeTable();
938
939 inline const flatbuffers::TypeTable *LessTypeTable();
940
941 inline const flatbuffers::TypeTable *GreaterTypeTable();
942
943 inline const flatbuffers::TypeTable *NotEqualTypeTable();
944
945 inline const flatbuffers::TypeTable *LessEqualTypeTable();
946
947 inline const flatbuffers::TypeTable *GreaterEqualTypeTable();
948
949 inline const flatbuffers::TypeTable *MinTypeTable();
950
951 inline const flatbuffers::TypeTable *SliceTypeTable();
952
953 inline const flatbuffers::TypeTable *FloorTypeTable();
954
955 inline const flatbuffers::TypeTable *AbsTypeTable();
956
957 inline const flatbuffers::TypeTable *NegTypeTable();
958
959 inline const flatbuffers::TypeTable *NegGradTypeTable();
960
961 inline const flatbuffers::TypeTable *ExpTypeTable();
962
963 inline const flatbuffers::TypeTable *CosTypeTable();
964
965 inline const flatbuffers::TypeTable *SinTypeTable();
966
967 inline const flatbuffers::TypeTable *SqrtTypeTable();
968
969 inline const flatbuffers::TypeTable *SquareTypeTable();
970
971 inline const flatbuffers::TypeTable *CeilTypeTable();
972
973 inline const flatbuffers::TypeTable *LogTypeTable();
974
975 inline const flatbuffers::TypeTable *LogGradTypeTable();
976
977 inline const flatbuffers::TypeTable *TanTypeTable();
978
979 inline const flatbuffers::TypeTable *AtanTypeTable();
980
981 inline const flatbuffers::TypeTable *AsinTypeTable();
982
983 inline const flatbuffers::TypeTable *ReshapeTypeTable();
984
985 inline const flatbuffers::TypeTable *PowerTypeTable();
986
987 inline const flatbuffers::TypeTable *PowerGradTypeTable();
988
989 inline const flatbuffers::TypeTable *ArgMaxTypeTable();
990
991 inline const flatbuffers::TypeTable *ArgMinTypeTable();
992
993 inline const flatbuffers::TypeTable *NetOutputTypeTable();
994
995 inline const flatbuffers::TypeTable *MatMulTypeTable();
996
997 inline const flatbuffers::TypeTable *PReLUTypeTable();
998
999 inline const flatbuffers::TypeTable *LeakyReLUTypeTable();
1000
1001 inline const flatbuffers::TypeTable *StridedSliceTypeTable();
1002
1003 inline const flatbuffers::TypeTable *StackTypeTable();
1004
1005 inline const flatbuffers::TypeTable *RangeTypeTable();
1006
1007 inline const flatbuffers::TypeTable *ExpandDimsTypeTable();
1008
1009 inline const flatbuffers::TypeTable *TileTypeTable();
1010
1011 inline const flatbuffers::TypeTable *CastTypeTable();
1012
1013 inline const flatbuffers::TypeTable *QuantDTypeCastTypeTable();
1014
1015 inline const flatbuffers::TypeTable *SplitTypeTable();
1016
1017 inline const flatbuffers::TypeTable *CropTypeTable();
1018
1019 inline const flatbuffers::TypeTable *PermuteTypeTable();
1020
1021 inline const flatbuffers::TypeTable *ClipTypeTable();
1022
1023 inline const flatbuffers::TypeTable *ConstantTypeTable();
1024
1025 inline const flatbuffers::TypeTable *EluTypeTable();
1026
1027 inline const flatbuffers::TypeTable *BroadcastTypeTable();
1028
1029 inline const flatbuffers::TypeTable *BroadcastToTypeTable();
1030
1031 inline const flatbuffers::TypeTable *LrnTypeTable();
1032
1033 inline const flatbuffers::TypeTable *ReduceTypeTable();
1034
1035 inline const flatbuffers::TypeTable *TransposeTypeTable();
1036
1037 inline const flatbuffers::TypeTable *SqueezeTypeTable();
1038
1039 inline const flatbuffers::TypeTable *UnsqueezeTypeTable();
1040
1041 inline const flatbuffers::TypeTable *UpsampleTypeTable();
1042
1043 inline const flatbuffers::TypeTable *DropoutTypeTable();
1044
1045 inline const flatbuffers::TypeTable *LocalResponseNormalizationTypeTable();
1046
1047 inline const flatbuffers::TypeTable *ZerosLikeTypeTable();
1048
1049 inline const flatbuffers::TypeTable *TopKTypeTable();
1050
1051 inline const flatbuffers::TypeTable *SpaceToDepthTypeTable();
1052
1053 inline const flatbuffers::TypeTable *SpaceToBatchTypeTable();
1054
1055 inline const flatbuffers::TypeTable *SparseToDenseTypeTable();
1056
1057 inline const flatbuffers::TypeTable *ReverseSequenceTypeTable();
1058
1059 inline const flatbuffers::TypeTable *RankTypeTable();
1060
1061 inline const flatbuffers::TypeTable *GatherTypeTable();
1062
1063 inline const flatbuffers::TypeTable *GatherNdTypeTable();
1064
1065 inline const flatbuffers::TypeTable *FillTypeTable();
1066
1067 inline const flatbuffers::TypeTable *DepthToSpaceTypeTable();
1068
1069 inline const flatbuffers::TypeTable *BatchToSpaceTypeTable();
1070
1071 inline const flatbuffers::TypeTable *BatchToSpaceNDTypeTable();
1072
1073 inline const flatbuffers::TypeTable *AddNTypeTable();
1074
1075 inline const flatbuffers::TypeTable *EmbeddingLookupTypeTable();
1076
1077 inline const flatbuffers::TypeTable *EmbeddingLookupSparseTypeTable();
1078
1079 inline const flatbuffers::TypeTable *FloorDivTypeTable();
1080
1081 inline const flatbuffers::TypeTable *FloorModTypeTable();
1082
1083 inline const flatbuffers::TypeTable *ModTypeTable();
1084
1085 inline const flatbuffers::TypeTable *L2NormTypeTable();
1086
1087 inline const flatbuffers::TypeTable *LogicalAndTypeTable();
1088
1089 inline const flatbuffers::TypeTable *LogicalOrTypeTable();
1090
1091 inline const flatbuffers::TypeTable *LogicalXorTypeTable();
1092
1093 inline const flatbuffers::TypeTable *LogicalNotTypeTable();
1094
1095 inline const flatbuffers::TypeTable *MatrixDiagTypeTable();
1096
1097 inline const flatbuffers::TypeTable *SelectTypeTable();
1098
1099 inline const flatbuffers::TypeTable *TfReduceTypeTable();
1100
1101 inline const flatbuffers::TypeTable *ReverseTypeTable();
1102
1103 inline const flatbuffers::TypeTable *RoundTypeTable();
1104
1105 inline const flatbuffers::TypeTable *ScatterTypeTable();
1106
1107 inline const flatbuffers::TypeTable *ScatterNDTypeTable();
1108
1109 inline const flatbuffers::TypeTable *UniqueTypeTable();
1110
1111 inline const flatbuffers::TypeTable *UnstackTypeTable();
1112
1113 inline const flatbuffers::TypeTable *OnnxInt8QuantizeTypeTable();
1114
1115 inline const flatbuffers::TypeTable *OnnxInt8DequantizeTypeTable();
1116
1117 inline const flatbuffers::TypeTable *FakeQuantWithMinMaxTypeTable();
1118
1119 inline const flatbuffers::TypeTable *FakeQuantWithMinMaxPerChannelTypeTable();
1120
1121 inline const flatbuffers::TypeTable *BatchNormFoldTypeTable();
1122
1123 inline const flatbuffers::TypeTable *MulFoldTypeTable();
1124
1125 inline const flatbuffers::TypeTable *AddFoldTypeTable();
1126
1127 inline const flatbuffers::TypeTable *SquaredDifferenceTypeTable();
1128
1129 inline const flatbuffers::TypeTable *TupleGetItemTypeTable();
1130
1131 inline const flatbuffers::TypeTable *ApplyMomentumTypeTable();
1132
1133 inline const flatbuffers::TypeTable *SgdTypeTable();
1134
1135 inline const flatbuffers::TypeTable *AdamTypeTable();
1136
1137 inline const flatbuffers::TypeTable *AssignTypeTable();
1138
1139 inline const flatbuffers::TypeTable *AssignAddTypeTable();
1140
1141 inline const flatbuffers::TypeTable *WhereTypeTable();
1142
1143 inline const flatbuffers::TypeTable *OneHotTypeTable();
1144
1145 inline const flatbuffers::TypeTable *LstmTypeTable();
1146
1147 inline const flatbuffers::TypeTable *PriorBoxTypeTable();
1148
1149 inline const flatbuffers::TypeTable *SpaceToBatchNDTypeTable();
1150
1151 inline const flatbuffers::TypeTable *MakeTupleTypeTable();
1152
1153 inline const flatbuffers::TypeTable *ToFormatTypeTable();
1154
1155 inline const flatbuffers::TypeTable *DependTypeTable();
1156
1157 inline const flatbuffers::TypeTable *ControlDependTypeTable();
1158
1159 inline const flatbuffers::TypeTable *ReturnTypeTable();
1160
1161 inline const flatbuffers::TypeTable *ProposalTypeTable();
1162
1163 inline const flatbuffers::TypeTable *CustomTypeTable();
1164
1165 inline const flatbuffers::TypeTable *BlackBoxTypeTable();
1166
1167 inline const flatbuffers::TypeTable *LshProjectionTypeTable();
1168
1169 inline const flatbuffers::TypeTable *HashtableLookupTypeTable();
1170
1171 inline const flatbuffers::TypeTable *SkipGramTypeTable();
1172
1173 inline const flatbuffers::TypeTable *CustomPredictTypeTable();
1174
1175 inline const flatbuffers::TypeTable *CustomNormalizeTypeTable();
1176
1177 inline const flatbuffers::TypeTable *CustomExtractFeaturesTypeTable();
1178
1179 inline const flatbuffers::TypeTable *AudioSpectrogramTypeTable();
1180
1181 inline const flatbuffers::TypeTable *MfccTypeTable();
1182
1183 inline const flatbuffers::TypeTable *RfftTypeTable();
1184
1185 inline const flatbuffers::TypeTable *FftRealTypeTable();
1186
1187 inline const flatbuffers::TypeTable *FftImagTypeTable();
1188
1189 inline const flatbuffers::TypeTable *DropoutGradTypeTable();
1190
1191 inline const flatbuffers::TypeTable *MaximumGradTypeTable();
1192
1193 inline const flatbuffers::TypeTable *MinimumGradTypeTable();
1194
1195 inline const flatbuffers::TypeTable *NonMaxSuppressionTypeTable();
1196
1197 inline const flatbuffers::TypeTable *InstanceNormTypeTable();
1198
1199 inline const flatbuffers::TypeTable *LoopTypeTable();
1200
1201 inline const flatbuffers::TypeTable *IdentityTypeTable();
1202
1203 inline const flatbuffers::TypeTable *LayerNormTypeTable();
1204
1205 inline const flatbuffers::TypeTable *WhileTypeTable();
1206
1207 inline const flatbuffers::TypeTable *UnsortedSegmentSumTypeTable();
1208
1209 inline const flatbuffers::TypeTable *OnesLikeTypeTable();
1210
1211 inline const flatbuffers::TypeTable *BinaryCrossEntropyTypeTable();
1212
1213 inline const flatbuffers::TypeTable *BinaryCrossEntropyGradTypeTable();
1214
1215 inline const flatbuffers::TypeTable *LpNormalizationTypeTable();
1216
1217 inline const flatbuffers::TypeTable *SwitchTypeTable();
1218
1219 inline const flatbuffers::TypeTable *PartialTypeTable();
1220
1221 inline const flatbuffers::TypeTable *TensorListFromTensorTypeTable();
1222
1223 inline const flatbuffers::TypeTable *TensorListStackTypeTable();
1224
1225 inline const flatbuffers::TypeTable *TensorListGetItemTypeTable();
1226
1227 inline const flatbuffers::TypeTable *TensorListSetItemTypeTable();
1228
1229 inline const flatbuffers::TypeTable *TensorListReserveTypeTable();
1230
1231 inline const flatbuffers::TypeTable *AllTypeTable();
1232
1233 inline const flatbuffers::TypeTable *AssertTypeTable();
1234
1235 inline const flatbuffers::TypeTable *SmoothL1LossTypeTable();
1236
1237 inline const flatbuffers::TypeTable *SmoothL1LossGradTypeTable();
1238
1239 inline const flatbuffers::TypeTable *SigmoidCrossEntropyWithLogitsTypeTable();
1240
1241 inline const flatbuffers::TypeTable *SigmoidCrossEntropyWithLogitsGradTypeTable();
1242
1243 inline const flatbuffers::TypeTable *ReciprocalTypeTable();
1244
1245 inline const flatbuffers::TypeTable *MergeTypeTable();
1246
1247 inline const flatbuffers::TypeTable *GeLUTypeTable();
1248
1249 enum ResizeMethod : int8_t {
1250 ResizeMethod_UNKNOWN = -1,
1251 ResizeMethod_LINEAR = 0,
1252 ResizeMethod_NEAREST = 1,
1253 ResizeMethod_CUBIC = 2,
1254 ResizeMethod_MIN = ResizeMethod_UNKNOWN,
1255 ResizeMethod_MAX = ResizeMethod_CUBIC
1256 };
1257
EnumValuesResizeMethod()1258 inline const ResizeMethod (&EnumValuesResizeMethod())[4] {
1259 static const ResizeMethod values[] = {
1260 ResizeMethod_UNKNOWN,
1261 ResizeMethod_LINEAR,
1262 ResizeMethod_NEAREST,
1263 ResizeMethod_CUBIC
1264 };
1265 return values;
1266 }
1267
EnumNamesResizeMethod()1268 inline const char * const *EnumNamesResizeMethod() {
1269 static const char * const names[5] = {
1270 "UNKNOWN",
1271 "LINEAR",
1272 "NEAREST",
1273 "CUBIC",
1274 nullptr
1275 };
1276 return names;
1277 }
1278
EnumNameResizeMethod(ResizeMethod e)1279 inline const char *EnumNameResizeMethod(ResizeMethod e) {
1280 if (flatbuffers::IsOutRange(e, ResizeMethod_UNKNOWN, ResizeMethod_CUBIC)) return "";
1281 const size_t index = static_cast<size_t>(e) - static_cast<size_t>(ResizeMethod_UNKNOWN);
1282 return EnumNamesResizeMethod()[index];
1283 }
1284
1285 enum CoordinateTransformMode : int8_t {
1286 CoordinateTransformMode_COMMON = 0,
1287 CoordinateTransformMode_HALF_PIXEL = 1,
1288 CoordinateTransformMode_PYTORCH_HALF_PIXEL = 2,
1289 CoordinateTransformMode_TF_HALF_PIXEL = 3,
1290 CoordinateTransformMode_TF_CROP_AND_RESIZE = 4,
1291 CoordinateTransformMode_ALIGN_CORNERS = 5,
1292 CoordinateTransformMode_ASYMMETRIC = 6,
1293 CoordinateTransformMode_ALIGN_CORNERS_WITH_HALF_PIEXL = 7,
1294 CoordinateTransformMode_MIN = CoordinateTransformMode_COMMON,
1295 CoordinateTransformMode_MAX = CoordinateTransformMode_ALIGN_CORNERS_WITH_HALF_PIEXL
1296 };
1297
EnumValuesCoordinateTransformMode()1298 inline const CoordinateTransformMode (&EnumValuesCoordinateTransformMode())[8] {
1299 static const CoordinateTransformMode values[] = {
1300 CoordinateTransformMode_COMMON,
1301 CoordinateTransformMode_HALF_PIXEL,
1302 CoordinateTransformMode_PYTORCH_HALF_PIXEL,
1303 CoordinateTransformMode_TF_HALF_PIXEL,
1304 CoordinateTransformMode_TF_CROP_AND_RESIZE,
1305 CoordinateTransformMode_ALIGN_CORNERS,
1306 CoordinateTransformMode_ASYMMETRIC,
1307 CoordinateTransformMode_ALIGN_CORNERS_WITH_HALF_PIEXL
1308 };
1309 return values;
1310 }
1311
EnumNamesCoordinateTransformMode()1312 inline const char * const *EnumNamesCoordinateTransformMode() {
1313 static const char * const names[9] = {
1314 "COMMON",
1315 "HALF_PIXEL",
1316 "PYTORCH_HALF_PIXEL",
1317 "TF_HALF_PIXEL",
1318 "TF_CROP_AND_RESIZE",
1319 "ALIGN_CORNERS",
1320 "ASYMMETRIC",
1321 "ALIGN_CORNERS_WITH_HALF_PIEXL",
1322 nullptr
1323 };
1324 return names;
1325 }
1326
EnumNameCoordinateTransformMode(CoordinateTransformMode e)1327 inline const char *EnumNameCoordinateTransformMode(CoordinateTransformMode e) {
1328 if (flatbuffers::IsOutRange(e, CoordinateTransformMode_COMMON, CoordinateTransformMode_ALIGN_CORNERS_WITH_HALF_PIEXL)) return "";
1329 const size_t index = static_cast<size_t>(e);
1330 return EnumNamesCoordinateTransformMode()[index];
1331 }
1332
1333 enum NearestMode : int8_t {
1334 NearestMode_NORMAL = 0,
1335 NearestMode_ROUND_HALF_DOWN = 1,
1336 NearestMode_ROUND_HALF_UP = 2,
1337 NearestMode_FLOOR = 3,
1338 NearestMode_CEIL = 4,
1339 NearestMode_MIN = NearestMode_NORMAL,
1340 NearestMode_MAX = NearestMode_CEIL
1341 };
1342
EnumValuesNearestMode()1343 inline const NearestMode (&EnumValuesNearestMode())[5] {
1344 static const NearestMode values[] = {
1345 NearestMode_NORMAL,
1346 NearestMode_ROUND_HALF_DOWN,
1347 NearestMode_ROUND_HALF_UP,
1348 NearestMode_FLOOR,
1349 NearestMode_CEIL
1350 };
1351 return values;
1352 }
1353
EnumNamesNearestMode()1354 inline const char * const *EnumNamesNearestMode() {
1355 static const char * const names[6] = {
1356 "NORMAL",
1357 "ROUND_HALF_DOWN",
1358 "ROUND_HALF_UP",
1359 "FLOOR",
1360 "CEIL",
1361 nullptr
1362 };
1363 return names;
1364 }
1365
EnumNameNearestMode(NearestMode e)1366 inline const char *EnumNameNearestMode(NearestMode e) {
1367 if (flatbuffers::IsOutRange(e, NearestMode_NORMAL, NearestMode_CEIL)) return "";
1368 const size_t index = static_cast<size_t>(e);
1369 return EnumNamesNearestMode()[index];
1370 }
1371
1372 enum Format : int32_t {
1373 Format_NCHW = 0,
1374 Format_NHWC = 1,
1375 Format_NHWC4 = 2,
1376 Format_HWKC = 3,
1377 Format_HWCK = 4,
1378 Format_KCHW = 5,
1379 Format_CKHW = 6,
1380 Format_KHWC = 7,
1381 Format_CHWK = 8,
1382 Format_HW = 9,
1383 Format_HW4 = 10,
1384 Format_NC = 11,
1385 Format_NC4 = 12,
1386 Format_NC4HW4 = 100,
1387 Format_NUM_OF_FORMAT = 101,
1388 Format_MIN = Format_NCHW,
1389 Format_MAX = Format_NUM_OF_FORMAT
1390 };
1391
EnumValuesFormat()1392 inline const Format (&EnumValuesFormat())[15] {
1393 static const Format values[] = {
1394 Format_NCHW,
1395 Format_NHWC,
1396 Format_NHWC4,
1397 Format_HWKC,
1398 Format_HWCK,
1399 Format_KCHW,
1400 Format_CKHW,
1401 Format_KHWC,
1402 Format_CHWK,
1403 Format_HW,
1404 Format_HW4,
1405 Format_NC,
1406 Format_NC4,
1407 Format_NC4HW4,
1408 Format_NUM_OF_FORMAT
1409 };
1410 return values;
1411 }
1412
EnumNameFormat(Format e)1413 inline const char *EnumNameFormat(Format e) {
1414 switch (e) {
1415 case Format_NCHW: return "NCHW";
1416 case Format_NHWC: return "NHWC";
1417 case Format_NHWC4: return "NHWC4";
1418 case Format_HWKC: return "HWKC";
1419 case Format_HWCK: return "HWCK";
1420 case Format_KCHW: return "KCHW";
1421 case Format_CKHW: return "CKHW";
1422 case Format_KHWC: return "KHWC";
1423 case Format_CHWK: return "CHWK";
1424 case Format_HW: return "HW";
1425 case Format_HW4: return "HW4";
1426 case Format_NC: return "NC";
1427 case Format_NC4: return "NC4";
1428 case Format_NC4HW4: return "NC4HW4";
1429 case Format_NUM_OF_FORMAT: return "NUM_OF_FORMAT";
1430 default: return "";
1431 }
1432 }
1433
1434 enum ActivationType : int8_t {
1435 ActivationType_NO_ACTIVATION = 0,
1436 ActivationType_RELU = 1,
1437 ActivationType_SIGMOID = 2,
1438 ActivationType_RELU6 = 3,
1439 ActivationType_ELU = 4,
1440 ActivationType_LEAKY_RELU = 5,
1441 ActivationType_ABS = 6,
1442 ActivationType_RELU1 = 7,
1443 ActivationType_SOFTSIGN = 8,
1444 ActivationType_SOFTPLUS = 9,
1445 ActivationType_TANH = 10,
1446 ActivationType_SELU = 11,
1447 ActivationType_HSWISH = 12,
1448 ActivationType_HSIGMOID = 13,
1449 ActivationType_THRESHOLDRELU = 14,
1450 ActivationType_LINEAR = 15,
1451 ActivationType_HARD_TANH = 16,
1452 ActivationType_SIGN = 17,
1453 ActivationType_SWISH = 18,
1454 ActivationType_UNKNOWN = 19,
1455 ActivationType_MIN = ActivationType_NO_ACTIVATION,
1456 ActivationType_MAX = ActivationType_UNKNOWN
1457 };
1458
EnumValuesActivationType()1459 inline const ActivationType (&EnumValuesActivationType())[20] {
1460 static const ActivationType values[] = {
1461 ActivationType_NO_ACTIVATION,
1462 ActivationType_RELU,
1463 ActivationType_SIGMOID,
1464 ActivationType_RELU6,
1465 ActivationType_ELU,
1466 ActivationType_LEAKY_RELU,
1467 ActivationType_ABS,
1468 ActivationType_RELU1,
1469 ActivationType_SOFTSIGN,
1470 ActivationType_SOFTPLUS,
1471 ActivationType_TANH,
1472 ActivationType_SELU,
1473 ActivationType_HSWISH,
1474 ActivationType_HSIGMOID,
1475 ActivationType_THRESHOLDRELU,
1476 ActivationType_LINEAR,
1477 ActivationType_HARD_TANH,
1478 ActivationType_SIGN,
1479 ActivationType_SWISH,
1480 ActivationType_UNKNOWN
1481 };
1482 return values;
1483 }
1484
EnumNamesActivationType()1485 inline const char * const *EnumNamesActivationType() {
1486 static const char * const names[21] = {
1487 "NO_ACTIVATION",
1488 "RELU",
1489 "SIGMOID",
1490 "RELU6",
1491 "ELU",
1492 "LEAKY_RELU",
1493 "ABS",
1494 "RELU1",
1495 "SOFTSIGN",
1496 "SOFTPLUS",
1497 "TANH",
1498 "SELU",
1499 "HSWISH",
1500 "HSIGMOID",
1501 "THRESHOLDRELU",
1502 "LINEAR",
1503 "HARD_TANH",
1504 "SIGN",
1505 "SWISH",
1506 "UNKNOWN",
1507 nullptr
1508 };
1509 return names;
1510 }
1511
EnumNameActivationType(ActivationType e)1512 inline const char *EnumNameActivationType(ActivationType e) {
1513 if (flatbuffers::IsOutRange(e, ActivationType_NO_ACTIVATION, ActivationType_UNKNOWN)) return "";
1514 const size_t index = static_cast<size_t>(e);
1515 return EnumNamesActivationType()[index];
1516 }
1517
1518 enum ReduceType : int8_t {
1519 ReduceType_REDUCE_MAX = 0,
1520 ReduceType_REDUCE_MEAN = 1,
1521 ReduceType_REDUCE_ALL = 2,
1522 ReduceType_REDUCE_ANY = 3,
1523 ReduceType_REDUCE_LOG_SUM_EXP = 4,
1524 ReduceType_REDUCE_PROD = 5,
1525 ReduceType_REDUCE_SUM = 6,
1526 ReduceType_UNKNOWN = 7,
1527 ReduceType_MIN = ReduceType_REDUCE_MAX,
1528 ReduceType_MAX = ReduceType_UNKNOWN
1529 };
1530
EnumValuesReduceType()1531 inline const ReduceType (&EnumValuesReduceType())[8] {
1532 static const ReduceType values[] = {
1533 ReduceType_REDUCE_MAX,
1534 ReduceType_REDUCE_MEAN,
1535 ReduceType_REDUCE_ALL,
1536 ReduceType_REDUCE_ANY,
1537 ReduceType_REDUCE_LOG_SUM_EXP,
1538 ReduceType_REDUCE_PROD,
1539 ReduceType_REDUCE_SUM,
1540 ReduceType_UNKNOWN
1541 };
1542 return values;
1543 }
1544
EnumNamesReduceType()1545 inline const char * const *EnumNamesReduceType() {
1546 static const char * const names[9] = {
1547 "REDUCE_MAX",
1548 "REDUCE_MEAN",
1549 "REDUCE_ALL",
1550 "REDUCE_ANY",
1551 "REDUCE_LOG_SUM_EXP",
1552 "REDUCE_PROD",
1553 "REDUCE_SUM",
1554 "UNKNOWN",
1555 nullptr
1556 };
1557 return names;
1558 }
1559
EnumNameReduceType(ReduceType e)1560 inline const char *EnumNameReduceType(ReduceType e) {
1561 if (flatbuffers::IsOutRange(e, ReduceType_REDUCE_MAX, ReduceType_UNKNOWN)) return "";
1562 const size_t index = static_cast<size_t>(e);
1563 return EnumNamesReduceType()[index];
1564 }
1565
1566 enum PoolMode : int8_t {
1567 PoolMode_MAX_POOLING = 0,
1568 PoolMode_MEAN_POOLING = 1,
1569 PoolMode_MIN = PoolMode_MAX_POOLING,
1570 PoolMode_MAX = PoolMode_MEAN_POOLING
1571 };
1572
EnumValuesPoolMode()1573 inline const PoolMode (&EnumValuesPoolMode())[2] {
1574 static const PoolMode values[] = {
1575 PoolMode_MAX_POOLING,
1576 PoolMode_MEAN_POOLING
1577 };
1578 return values;
1579 }
1580
EnumNamesPoolMode()1581 inline const char * const *EnumNamesPoolMode() {
1582 static const char * const names[3] = {
1583 "MAX_POOLING",
1584 "MEAN_POOLING",
1585 nullptr
1586 };
1587 return names;
1588 }
1589
EnumNamePoolMode(PoolMode e)1590 inline const char *EnumNamePoolMode(PoolMode e) {
1591 if (flatbuffers::IsOutRange(e, PoolMode_MAX_POOLING, PoolMode_MEAN_POOLING)) return "";
1592 const size_t index = static_cast<size_t>(e);
1593 return EnumNamesPoolMode()[index];
1594 }
1595
1596 enum EltwiseMode : int8_t {
1597 EltwiseMode_PROD = 0,
1598 EltwiseMode_SUM = 1,
1599 EltwiseMode_MAXIMUM = 2,
1600 EltwiseMode_UNKNOWN = 3,
1601 EltwiseMode_MIN = EltwiseMode_PROD,
1602 EltwiseMode_MAX = EltwiseMode_UNKNOWN
1603 };
1604
EnumValuesEltwiseMode()1605 inline const EltwiseMode (&EnumValuesEltwiseMode())[4] {
1606 static const EltwiseMode values[] = {
1607 EltwiseMode_PROD,
1608 EltwiseMode_SUM,
1609 EltwiseMode_MAXIMUM,
1610 EltwiseMode_UNKNOWN
1611 };
1612 return values;
1613 }
1614
EnumNamesEltwiseMode()1615 inline const char * const *EnumNamesEltwiseMode() {
1616 static const char * const names[5] = {
1617 "PROD",
1618 "SUM",
1619 "MAXIMUM",
1620 "UNKNOWN",
1621 nullptr
1622 };
1623 return names;
1624 }
1625
EnumNameEltwiseMode(EltwiseMode e)1626 inline const char *EnumNameEltwiseMode(EltwiseMode e) {
1627 if (flatbuffers::IsOutRange(e, EltwiseMode_PROD, EltwiseMode_UNKNOWN)) return "";
1628 const size_t index = static_cast<size_t>(e);
1629 return EnumNamesEltwiseMode()[index];
1630 }
1631
1632 enum PadMode : int8_t {
1633 PadMode_NOTSET = 0,
1634 PadMode_SAME_UPPER = 1,
1635 PadMode_VALID = 2,
1636 PadMode_CAFFE = 4,
1637 PadMode_SAME_LOWER = 5,
1638 PadMode_MIN = PadMode_NOTSET,
1639 PadMode_MAX = PadMode_SAME_LOWER
1640 };
1641
EnumValuesPadMode()1642 inline const PadMode (&EnumValuesPadMode())[5] {
1643 static const PadMode values[] = {
1644 PadMode_NOTSET,
1645 PadMode_SAME_UPPER,
1646 PadMode_VALID,
1647 PadMode_CAFFE,
1648 PadMode_SAME_LOWER
1649 };
1650 return values;
1651 }
1652
EnumNamesPadMode()1653 inline const char * const *EnumNamesPadMode() {
1654 static const char * const names[7] = {
1655 "NOTSET",
1656 "SAME_UPPER",
1657 "VALID",
1658 "",
1659 "CAFFE",
1660 "SAME_LOWER",
1661 nullptr
1662 };
1663 return names;
1664 }
1665
EnumNamePadMode(PadMode e)1666 inline const char *EnumNamePadMode(PadMode e) {
1667 if (flatbuffers::IsOutRange(e, PadMode_NOTSET, PadMode_SAME_LOWER)) return "";
1668 const size_t index = static_cast<size_t>(e);
1669 return EnumNamesPadMode()[index];
1670 }
1671
1672 enum RoundMode : int8_t {
1673 RoundMode_FLOOR = 0,
1674 RoundMode_CEIL = 1,
1675 RoundMode_MIN = RoundMode_FLOOR,
1676 RoundMode_MAX = RoundMode_CEIL
1677 };
1678
EnumValuesRoundMode()1679 inline const RoundMode (&EnumValuesRoundMode())[2] {
1680 static const RoundMode values[] = {
1681 RoundMode_FLOOR,
1682 RoundMode_CEIL
1683 };
1684 return values;
1685 }
1686
EnumNamesRoundMode()1687 inline const char * const *EnumNamesRoundMode() {
1688 static const char * const names[3] = {
1689 "FLOOR",
1690 "CEIL",
1691 nullptr
1692 };
1693 return names;
1694 }
1695
EnumNameRoundMode(RoundMode e)1696 inline const char *EnumNameRoundMode(RoundMode e) {
1697 if (flatbuffers::IsOutRange(e, RoundMode_FLOOR, RoundMode_CEIL)) return "";
1698 const size_t index = static_cast<size_t>(e);
1699 return EnumNamesRoundMode()[index];
1700 }
1701
1702 enum PaddingMode : int8_t {
1703 PaddingMode_CONSTANT = 0,
1704 PaddingMode_REFLECT = 1,
1705 PaddingMode_SYMMETRIC = 2,
1706 PaddingMode_MODE_RESERVED = 3,
1707 PaddingMode_MIN = PaddingMode_CONSTANT,
1708 PaddingMode_MAX = PaddingMode_MODE_RESERVED
1709 };
1710
EnumValuesPaddingMode()1711 inline const PaddingMode (&EnumValuesPaddingMode())[4] {
1712 static const PaddingMode values[] = {
1713 PaddingMode_CONSTANT,
1714 PaddingMode_REFLECT,
1715 PaddingMode_SYMMETRIC,
1716 PaddingMode_MODE_RESERVED
1717 };
1718 return values;
1719 }
1720
EnumNamesPaddingMode()1721 inline const char * const *EnumNamesPaddingMode() {
1722 static const char * const names[5] = {
1723 "CONSTANT",
1724 "REFLECT",
1725 "SYMMETRIC",
1726 "MODE_RESERVED",
1727 nullptr
1728 };
1729 return names;
1730 }
1731
EnumNamePaddingMode(PaddingMode e)1732 inline const char *EnumNamePaddingMode(PaddingMode e) {
1733 if (flatbuffers::IsOutRange(e, PaddingMode_CONSTANT, PaddingMode_MODE_RESERVED)) return "";
1734 const size_t index = static_cast<size_t>(e);
1735 return EnumNamesPaddingMode()[index];
1736 }
1737
1738 enum LshProjectionType : int8_t {
1739 LshProjectionType_UNKNOWN = 0,
1740 LshProjectionType_SPARSE = 1,
1741 LshProjectionType_DENSE = 2,
1742 LshProjectionType_MIN = LshProjectionType_UNKNOWN,
1743 LshProjectionType_MAX = LshProjectionType_DENSE
1744 };
1745
EnumValuesLshProjectionType()1746 inline const LshProjectionType (&EnumValuesLshProjectionType())[3] {
1747 static const LshProjectionType values[] = {
1748 LshProjectionType_UNKNOWN,
1749 LshProjectionType_SPARSE,
1750 LshProjectionType_DENSE
1751 };
1752 return values;
1753 }
1754
EnumNamesLshProjectionType()1755 inline const char * const *EnumNamesLshProjectionType() {
1756 static const char * const names[4] = {
1757 "UNKNOWN",
1758 "SPARSE",
1759 "DENSE",
1760 nullptr
1761 };
1762 return names;
1763 }
1764
EnumNameLshProjectionType(LshProjectionType e)1765 inline const char *EnumNameLshProjectionType(LshProjectionType e) {
1766 if (flatbuffers::IsOutRange(e, LshProjectionType_UNKNOWN, LshProjectionType_DENSE)) return "";
1767 const size_t index = static_cast<size_t>(e);
1768 return EnumNamesLshProjectionType()[index];
1769 }
1770
1771 enum ReduceMode : int8_t {
1772 ReduceMode_ReduceMean = 0,
1773 ReduceMode_ReduceMax = 1,
1774 ReduceMode_ReduceMin = 2,
1775 ReduceMode_ReduceProd = 3,
1776 ReduceMode_ReduceSum = 4,
1777 ReduceMode_ReduceSumSquare = 5,
1778 ReduceMode_ReduceASum = 6,
1779 ReduceMode_ReduceAll = 7,
1780 ReduceMode_MIN = ReduceMode_ReduceMean,
1781 ReduceMode_MAX = ReduceMode_ReduceAll
1782 };
1783
EnumValuesReduceMode()1784 inline const ReduceMode (&EnumValuesReduceMode())[8] {
1785 static const ReduceMode values[] = {
1786 ReduceMode_ReduceMean,
1787 ReduceMode_ReduceMax,
1788 ReduceMode_ReduceMin,
1789 ReduceMode_ReduceProd,
1790 ReduceMode_ReduceSum,
1791 ReduceMode_ReduceSumSquare,
1792 ReduceMode_ReduceASum,
1793 ReduceMode_ReduceAll
1794 };
1795 return values;
1796 }
1797
EnumNamesReduceMode()1798 inline const char * const *EnumNamesReduceMode() {
1799 static const char * const names[9] = {
1800 "ReduceMean",
1801 "ReduceMax",
1802 "ReduceMin",
1803 "ReduceProd",
1804 "ReduceSum",
1805 "ReduceSumSquare",
1806 "ReduceASum",
1807 "ReduceAll",
1808 nullptr
1809 };
1810 return names;
1811 }
1812
EnumNameReduceMode(ReduceMode e)1813 inline const char *EnumNameReduceMode(ReduceMode e) {
1814 if (flatbuffers::IsOutRange(e, ReduceMode_ReduceMean, ReduceMode_ReduceAll)) return "";
1815 const size_t index = static_cast<size_t>(e);
1816 return EnumNamesReduceMode()[index];
1817 }
1818
1819 struct PadT : public flatbuffers::NativeTable {
1820 typedef Pad TableType;
1821 std::vector<int32_t> paddings{};
1822 mindspore::schema::v0::PaddingMode paddingMode = mindspore::schema::v0::PaddingMode_CONSTANT;
1823 float constantValue = 0.0f;
1824 };
1825
1826 struct Pad FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1827 typedef PadT NativeTableType;
1828 typedef PadBuilder Builder;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1829 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1830 return PadTypeTable();
1831 }
1832 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1833 VT_PADDINGS = 4,
1834 VT_PADDINGMODE = 6,
1835 VT_CONSTANTVALUE = 8
1836 };
paddingsFLATBUFFERS_FINAL_CLASS1837 const flatbuffers::Vector<int32_t> *paddings() const {
1838 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_PADDINGS);
1839 }
mutable_paddingsFLATBUFFERS_FINAL_CLASS1840 flatbuffers::Vector<int32_t> *mutable_paddings() {
1841 return GetPointer<flatbuffers::Vector<int32_t> *>(VT_PADDINGS);
1842 }
paddingModeFLATBUFFERS_FINAL_CLASS1843 mindspore::schema::v0::PaddingMode paddingMode() const {
1844 return static_cast<mindspore::schema::v0::PaddingMode>(GetField<int8_t>(VT_PADDINGMODE, 0));
1845 }
mutate_paddingModeFLATBUFFERS_FINAL_CLASS1846 bool mutate_paddingMode(mindspore::schema::v0::PaddingMode _paddingMode) {
1847 return SetField<int8_t>(VT_PADDINGMODE, static_cast<int8_t>(_paddingMode), 0);
1848 }
constantValueFLATBUFFERS_FINAL_CLASS1849 float constantValue() const {
1850 return GetField<float>(VT_CONSTANTVALUE, 0.0f);
1851 }
mutate_constantValueFLATBUFFERS_FINAL_CLASS1852 bool mutate_constantValue(float _constantValue) {
1853 return SetField<float>(VT_CONSTANTVALUE, _constantValue, 0.0f);
1854 }
VerifyFLATBUFFERS_FINAL_CLASS1855 bool Verify(flatbuffers::Verifier &verifier) const {
1856 return VerifyTableStart(verifier) &&
1857 VerifyOffset(verifier, VT_PADDINGS) &&
1858 verifier.VerifyVector(paddings()) &&
1859 VerifyField<int8_t>(verifier, VT_PADDINGMODE) &&
1860 VerifyField<float>(verifier, VT_CONSTANTVALUE) &&
1861 verifier.EndTable();
1862 }
1863 PadT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1864 void UnPackTo(PadT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1865 static flatbuffers::Offset<Pad> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1866 };
1867
1868 struct PadBuilder {
1869 typedef Pad Table;
1870 flatbuffers::FlatBufferBuilder &fbb_;
1871 flatbuffers::uoffset_t start_;
add_paddingsPadBuilder1872 void add_paddings(flatbuffers::Offset<flatbuffers::Vector<int32_t>> paddings) {
1873 fbb_.AddOffset(Pad::VT_PADDINGS, paddings);
1874 }
add_paddingModePadBuilder1875 void add_paddingMode(mindspore::schema::v0::PaddingMode paddingMode) {
1876 fbb_.AddElement<int8_t>(Pad::VT_PADDINGMODE, static_cast<int8_t>(paddingMode), 0);
1877 }
add_constantValuePadBuilder1878 void add_constantValue(float constantValue) {
1879 fbb_.AddElement<float>(Pad::VT_CONSTANTVALUE, constantValue, 0.0f);
1880 }
PadBuilderPadBuilder1881 explicit PadBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1882 : fbb_(_fbb) {
1883 start_ = fbb_.StartTable();
1884 }
FinishPadBuilder1885 flatbuffers::Offset<Pad> Finish() {
1886 const auto end = fbb_.EndTable(start_);
1887 auto o = flatbuffers::Offset<Pad>(end);
1888 return o;
1889 }
1890 };
1891
1892 inline flatbuffers::Offset<Pad> CreatePad(
1893 flatbuffers::FlatBufferBuilder &_fbb,
1894 flatbuffers::Offset<flatbuffers::Vector<int32_t>> paddings = 0,
1895 mindspore::schema::v0::PaddingMode paddingMode = mindspore::schema::v0::PaddingMode_CONSTANT,
1896 float constantValue = 0.0f) {
1897 PadBuilder builder_(_fbb);
1898 builder_.add_constantValue(constantValue);
1899 builder_.add_paddings(paddings);
1900 builder_.add_paddingMode(paddingMode);
1901 return builder_.Finish();
1902 }
1903
1904 inline flatbuffers::Offset<Pad> CreatePadDirect(
1905 flatbuffers::FlatBufferBuilder &_fbb,
1906 const std::vector<int32_t> *paddings = nullptr,
1907 mindspore::schema::v0::PaddingMode paddingMode = mindspore::schema::v0::PaddingMode_CONSTANT,
1908 float constantValue = 0.0f) {
1909 auto paddings__ = paddings ? _fbb.CreateVector<int32_t>(*paddings) : 0;
1910 return mindspore::schema::v0::CreatePad(
1911 _fbb,
1912 paddings__,
1913 paddingMode,
1914 constantValue);
1915 }
1916
1917 flatbuffers::Offset<Pad> CreatePad(flatbuffers::FlatBufferBuilder &_fbb, const PadT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1918
1919 struct MaximumT : public flatbuffers::NativeTable {
1920 typedef Maximum TableType;
1921 };
1922
1923 struct Maximum FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1924 typedef MaximumT NativeTableType;
1925 typedef MaximumBuilder Builder;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1926 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1927 return MaximumTypeTable();
1928 }
VerifyFLATBUFFERS_FINAL_CLASS1929 bool Verify(flatbuffers::Verifier &verifier) const {
1930 return VerifyTableStart(verifier) &&
1931 verifier.EndTable();
1932 }
1933 MaximumT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1934 void UnPackTo(MaximumT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1935 static flatbuffers::Offset<Maximum> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MaximumT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1936 };
1937
1938 struct MaximumBuilder {
1939 typedef Maximum Table;
1940 flatbuffers::FlatBufferBuilder &fbb_;
1941 flatbuffers::uoffset_t start_;
MaximumBuilderMaximumBuilder1942 explicit MaximumBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1943 : fbb_(_fbb) {
1944 start_ = fbb_.StartTable();
1945 }
FinishMaximumBuilder1946 flatbuffers::Offset<Maximum> Finish() {
1947 const auto end = fbb_.EndTable(start_);
1948 auto o = flatbuffers::Offset<Maximum>(end);
1949 return o;
1950 }
1951 };
1952
CreateMaximum(flatbuffers::FlatBufferBuilder & _fbb)1953 inline flatbuffers::Offset<Maximum> CreateMaximum(
1954 flatbuffers::FlatBufferBuilder &_fbb) {
1955 MaximumBuilder builder_(_fbb);
1956 return builder_.Finish();
1957 }
1958
1959 flatbuffers::Offset<Maximum> CreateMaximum(flatbuffers::FlatBufferBuilder &_fbb, const MaximumT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1960
1961 struct MinimumT : public flatbuffers::NativeTable {
1962 typedef Minimum TableType;
1963 };
1964
1965 struct Minimum FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1966 typedef MinimumT NativeTableType;
1967 typedef MinimumBuilder Builder;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1968 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1969 return MinimumTypeTable();
1970 }
VerifyFLATBUFFERS_FINAL_CLASS1971 bool Verify(flatbuffers::Verifier &verifier) const {
1972 return VerifyTableStart(verifier) &&
1973 verifier.EndTable();
1974 }
1975 MinimumT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1976 void UnPackTo(MinimumT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1977 static flatbuffers::Offset<Minimum> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MinimumT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1978 };
1979
1980 struct MinimumBuilder {
1981 typedef Minimum Table;
1982 flatbuffers::FlatBufferBuilder &fbb_;
1983 flatbuffers::uoffset_t start_;
MinimumBuilderMinimumBuilder1984 explicit MinimumBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1985 : fbb_(_fbb) {
1986 start_ = fbb_.StartTable();
1987 }
FinishMinimumBuilder1988 flatbuffers::Offset<Minimum> Finish() {
1989 const auto end = fbb_.EndTable(start_);
1990 auto o = flatbuffers::Offset<Minimum>(end);
1991 return o;
1992 }
1993 };
1994
CreateMinimum(flatbuffers::FlatBufferBuilder & _fbb)1995 inline flatbuffers::Offset<Minimum> CreateMinimum(
1996 flatbuffers::FlatBufferBuilder &_fbb) {
1997 MinimumBuilder builder_(_fbb);
1998 return builder_.Finish();
1999 }
2000
2001 flatbuffers::Offset<Minimum> CreateMinimum(flatbuffers::FlatBufferBuilder &_fbb, const MinimumT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2002
2003 struct FlattenT : public flatbuffers::NativeTable {
2004 typedef Flatten TableType;
2005 };
2006
2007 struct Flatten FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2008 typedef FlattenT NativeTableType;
2009 typedef FlattenBuilder Builder;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS2010 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
2011 return FlattenTypeTable();
2012 }
VerifyFLATBUFFERS_FINAL_CLASS2013 bool Verify(flatbuffers::Verifier &verifier) const {
2014 return VerifyTableStart(verifier) &&
2015 verifier.EndTable();
2016 }
2017 FlattenT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2018 void UnPackTo(FlattenT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2019 static flatbuffers::Offset<Flatten> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FlattenT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2020 };
2021
2022 struct FlattenBuilder {
2023 typedef Flatten Table;
2024 flatbuffers::FlatBufferBuilder &fbb_;
2025 flatbuffers::uoffset_t start_;
FlattenBuilderFlattenBuilder2026 explicit FlattenBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2027 : fbb_(_fbb) {
2028 start_ = fbb_.StartTable();
2029 }
FinishFlattenBuilder2030 flatbuffers::Offset<Flatten> Finish() {
2031 const auto end = fbb_.EndTable(start_);
2032 auto o = flatbuffers::Offset<Flatten>(end);
2033 return o;
2034 }
2035 };
2036
CreateFlatten(flatbuffers::FlatBufferBuilder & _fbb)2037 inline flatbuffers::Offset<Flatten> CreateFlatten(
2038 flatbuffers::FlatBufferBuilder &_fbb) {
2039 FlattenBuilder builder_(_fbb);
2040 return builder_.Finish();
2041 }
2042
2043 flatbuffers::Offset<Flatten> CreateFlatten(flatbuffers::FlatBufferBuilder &_fbb, const FlattenT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2044
2045 struct FlattenGradT : public flatbuffers::NativeTable {
2046 typedef FlattenGrad TableType;
2047 };
2048
2049 struct FlattenGrad FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2050 typedef FlattenGradT NativeTableType;
2051 typedef FlattenGradBuilder Builder;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS2052 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
2053 return FlattenGradTypeTable();
2054 }
VerifyFLATBUFFERS_FINAL_CLASS2055 bool Verify(flatbuffers::Verifier &verifier) const {
2056 return VerifyTableStart(verifier) &&
2057 verifier.EndTable();
2058 }
2059 FlattenGradT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2060 void UnPackTo(FlattenGradT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2061 static flatbuffers::Offset<FlattenGrad> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FlattenGradT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2062 };
2063
2064 struct FlattenGradBuilder {
2065 typedef FlattenGrad Table;
2066 flatbuffers::FlatBufferBuilder &fbb_;
2067 flatbuffers::uoffset_t start_;
FlattenGradBuilderFlattenGradBuilder2068 explicit FlattenGradBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2069 : fbb_(_fbb) {
2070 start_ = fbb_.StartTable();
2071 }
FinishFlattenGradBuilder2072 flatbuffers::Offset<FlattenGrad> Finish() {
2073 const auto end = fbb_.EndTable(start_);
2074 auto o = flatbuffers::Offset<FlattenGrad>(end);
2075 return o;
2076 }
2077 };
2078
CreateFlattenGrad(flatbuffers::FlatBufferBuilder & _fbb)2079 inline flatbuffers::Offset<FlattenGrad> CreateFlattenGrad(
2080 flatbuffers::FlatBufferBuilder &_fbb) {
2081 FlattenGradBuilder builder_(_fbb);
2082 return builder_.Finish();
2083 }
2084
2085 flatbuffers::Offset<FlattenGrad> CreateFlattenGrad(flatbuffers::FlatBufferBuilder &_fbb, const FlattenGradT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2086
2087 struct ConcatT : public flatbuffers::NativeTable {
2088 typedef Concat TableType;
2089 int32_t axis = 0;
2090 int32_t n = 0;
2091 };
2092
2093 struct Concat FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2094 typedef ConcatT NativeTableType;
2095 typedef ConcatBuilder Builder;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS2096 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
2097 return ConcatTypeTable();
2098 }
2099 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2100 VT_AXIS = 4,
2101 VT_N = 6
2102 };
axisFLATBUFFERS_FINAL_CLASS2103 int32_t axis() const {
2104 return GetField<int32_t>(VT_AXIS, 0);
2105 }
mutate_axisFLATBUFFERS_FINAL_CLASS2106 bool mutate_axis(int32_t _axis) {
2107 return SetField<int32_t>(VT_AXIS, _axis, 0);
2108 }
nFLATBUFFERS_FINAL_CLASS2109 int32_t n() const {
2110 return GetField<int32_t>(VT_N, 0);
2111 }
mutate_nFLATBUFFERS_FINAL_CLASS2112 bool mutate_n(int32_t _n) {
2113 return SetField<int32_t>(VT_N, _n, 0);
2114 }
VerifyFLATBUFFERS_FINAL_CLASS2115 bool Verify(flatbuffers::Verifier &verifier) const {
2116 return VerifyTableStart(verifier) &&
2117 VerifyField<int32_t>(verifier, VT_AXIS) &&
2118 VerifyField<int32_t>(verifier, VT_N) &&
2119 verifier.EndTable();
2120 }
2121 ConcatT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2122 void UnPackTo(ConcatT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2123 static flatbuffers::Offset<Concat> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2124 };
2125
2126 struct ConcatBuilder {
2127 typedef Concat Table;
2128 flatbuffers::FlatBufferBuilder &fbb_;
2129 flatbuffers::uoffset_t start_;
add_axisConcatBuilder2130 void add_axis(int32_t axis) {
2131 fbb_.AddElement<int32_t>(Concat::VT_AXIS, axis, 0);
2132 }
add_nConcatBuilder2133 void add_n(int32_t n) {
2134 fbb_.AddElement<int32_t>(Concat::VT_N, n, 0);
2135 }
ConcatBuilderConcatBuilder2136 explicit ConcatBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2137 : fbb_(_fbb) {
2138 start_ = fbb_.StartTable();
2139 }
FinishConcatBuilder2140 flatbuffers::Offset<Concat> Finish() {
2141 const auto end = fbb_.EndTable(start_);
2142 auto o = flatbuffers::Offset<Concat>(end);
2143 return o;
2144 }
2145 };
2146
2147 inline flatbuffers::Offset<Concat> CreateConcat(
2148 flatbuffers::FlatBufferBuilder &_fbb,
2149 int32_t axis = 0,
2150 int32_t n = 0) {
2151 ConcatBuilder builder_(_fbb);
2152 builder_.add_n(n);
2153 builder_.add_axis(axis);
2154 return builder_.Finish();
2155 }
2156
2157 flatbuffers::Offset<Concat> CreateConcat(flatbuffers::FlatBufferBuilder &_fbb, const ConcatT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2158
2159 struct SoftMaxT : public flatbuffers::NativeTable {
2160 typedef SoftMax TableType;
2161 int32_t axis = -1;
2162 };
2163
2164 struct SoftMax FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2165 typedef SoftMaxT NativeTableType;
2166 typedef SoftMaxBuilder Builder;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS2167 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
2168 return SoftMaxTypeTable();
2169 }
2170 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2171 VT_AXIS = 4
2172 };
axisFLATBUFFERS_FINAL_CLASS2173 int32_t axis() const {
2174 return GetField<int32_t>(VT_AXIS, -1);
2175 }
mutate_axisFLATBUFFERS_FINAL_CLASS2176 bool mutate_axis(int32_t _axis) {
2177 return SetField<int32_t>(VT_AXIS, _axis, -1);
2178 }
VerifyFLATBUFFERS_FINAL_CLASS2179 bool Verify(flatbuffers::Verifier &verifier) const {
2180 return VerifyTableStart(verifier) &&
2181 VerifyField<int32_t>(verifier, VT_AXIS) &&
2182 verifier.EndTable();
2183 }
2184 SoftMaxT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2185 void UnPackTo(SoftMaxT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2186 static flatbuffers::Offset<SoftMax> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SoftMaxT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2187 };
2188
2189 struct SoftMaxBuilder {
2190 typedef SoftMax Table;
2191 flatbuffers::FlatBufferBuilder &fbb_;
2192 flatbuffers::uoffset_t start_;
add_axisSoftMaxBuilder2193 void add_axis(int32_t axis) {
2194 fbb_.AddElement<int32_t>(SoftMax::VT_AXIS, axis, -1);
2195 }
SoftMaxBuilderSoftMaxBuilder2196 explicit SoftMaxBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2197 : fbb_(_fbb) {
2198 start_ = fbb_.StartTable();
2199 }
FinishSoftMaxBuilder2200 flatbuffers::Offset<SoftMax> Finish() {
2201 const auto end = fbb_.EndTable(start_);
2202 auto o = flatbuffers::Offset<SoftMax>(end);
2203 return o;
2204 }
2205 };
2206
2207 inline flatbuffers::Offset<SoftMax> CreateSoftMax(
2208 flatbuffers::FlatBufferBuilder &_fbb,
2209 int32_t axis = -1) {
2210 SoftMaxBuilder builder_(_fbb);
2211 builder_.add_axis(axis);
2212 return builder_.Finish();
2213 }
2214
2215 flatbuffers::Offset<SoftMax> CreateSoftMax(flatbuffers::FlatBufferBuilder &_fbb, const SoftMaxT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2216
2217 struct ActivationT : public flatbuffers::NativeTable {
2218 typedef Activation TableType;
2219 mindspore::schema::v0::ActivationType type = mindspore::schema::v0::ActivationType_NO_ACTIVATION;
2220 float alpha = 0.2f;
2221 float min_val = -1.0f;
2222 float max_val = 1.0f;
2223 };
2224
2225 struct Activation FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2226 typedef ActivationT NativeTableType;
2227 typedef ActivationBuilder Builder;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS2228 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
2229 return ActivationTypeTable();
2230 }
2231 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2232 VT_TYPE = 4,
2233 VT_ALPHA = 6,
2234 VT_MIN_VAL = 8,
2235 VT_MAX_VAL = 10
2236 };
typeFLATBUFFERS_FINAL_CLASS2237 mindspore::schema::v0::ActivationType type() const {
2238 return static_cast<mindspore::schema::v0::ActivationType>(GetField<int8_t>(VT_TYPE, 0));
2239 }
mutate_typeFLATBUFFERS_FINAL_CLASS2240 bool mutate_type(mindspore::schema::v0::ActivationType _type) {
2241 return SetField<int8_t>(VT_TYPE, static_cast<int8_t>(_type), 0);
2242 }
alphaFLATBUFFERS_FINAL_CLASS2243 float alpha() const {
2244 return GetField<float>(VT_ALPHA, 0.2f);
2245 }
mutate_alphaFLATBUFFERS_FINAL_CLASS2246 bool mutate_alpha(float _alpha) {
2247 return SetField<float>(VT_ALPHA, _alpha, 0.2f);
2248 }
min_valFLATBUFFERS_FINAL_CLASS2249 float min_val() const {
2250 return GetField<float>(VT_MIN_VAL, -1.0f);
2251 }
mutate_min_valFLATBUFFERS_FINAL_CLASS2252 bool mutate_min_val(float _min_val) {
2253 return SetField<float>(VT_MIN_VAL, _min_val, -1.0f);
2254 }
max_valFLATBUFFERS_FINAL_CLASS2255 float max_val() const {
2256 return GetField<float>(VT_MAX_VAL, 1.0f);
2257 }
mutate_max_valFLATBUFFERS_FINAL_CLASS2258 bool mutate_max_val(float _max_val) {
2259 return SetField<float>(VT_MAX_VAL, _max_val, 1.0f);
2260 }
VerifyFLATBUFFERS_FINAL_CLASS2261 bool Verify(flatbuffers::Verifier &verifier) const {
2262 return VerifyTableStart(verifier) &&
2263 VerifyField<int8_t>(verifier, VT_TYPE) &&
2264 VerifyField<float>(verifier, VT_ALPHA) &&
2265 VerifyField<float>(verifier, VT_MIN_VAL) &&
2266 VerifyField<float>(verifier, VT_MAX_VAL) &&
2267 verifier.EndTable();
2268 }
2269 ActivationT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2270 void UnPackTo(ActivationT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2271 static flatbuffers::Offset<Activation> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ActivationT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2272 };
2273
2274 struct ActivationBuilder {
2275 typedef Activation Table;
2276 flatbuffers::FlatBufferBuilder &fbb_;
2277 flatbuffers::uoffset_t start_;
add_typeActivationBuilder2278 void add_type(mindspore::schema::v0::ActivationType type) {
2279 fbb_.AddElement<int8_t>(Activation::VT_TYPE, static_cast<int8_t>(type), 0);
2280 }
add_alphaActivationBuilder2281 void add_alpha(float alpha) {
2282 fbb_.AddElement<float>(Activation::VT_ALPHA, alpha, 0.2f);
2283 }
add_min_valActivationBuilder2284 void add_min_val(float min_val) {
2285 fbb_.AddElement<float>(Activation::VT_MIN_VAL, min_val, -1.0f);
2286 }
add_max_valActivationBuilder2287 void add_max_val(float max_val) {
2288 fbb_.AddElement<float>(Activation::VT_MAX_VAL, max_val, 1.0f);
2289 }
ActivationBuilderActivationBuilder2290 explicit ActivationBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2291 : fbb_(_fbb) {
2292 start_ = fbb_.StartTable();
2293 }
FinishActivationBuilder2294 flatbuffers::Offset<Activation> Finish() {
2295 const auto end = fbb_.EndTable(start_);
2296 auto o = flatbuffers::Offset<Activation>(end);
2297 return o;
2298 }
2299 };
2300
2301 inline flatbuffers::Offset<Activation> CreateActivation(
2302 flatbuffers::FlatBufferBuilder &_fbb,
2303 mindspore::schema::v0::ActivationType type = mindspore::schema::v0::ActivationType_NO_ACTIVATION,
2304 float alpha = 0.2f,
2305 float min_val = -1.0f,
2306 float max_val = 1.0f) {
2307 ActivationBuilder builder_(_fbb);
2308 builder_.add_max_val(max_val);
2309 builder_.add_min_val(min_val);
2310 builder_.add_alpha(alpha);
2311 builder_.add_type(type);
2312 return builder_.Finish();
2313 }
2314
2315 flatbuffers::Offset<Activation> CreateActivation(flatbuffers::FlatBufferBuilder &_fbb, const ActivationT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2316
2317 struct ActivationGradT : public flatbuffers::NativeTable {
2318 typedef ActivationGrad TableType;
2319 mindspore::schema::v0::ActivationType type = mindspore::schema::v0::ActivationType_NO_ACTIVATION;
2320 float alpha = 0.2f;
2321 };
2322
2323 struct ActivationGrad FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2324 typedef ActivationGradT NativeTableType;
2325 typedef ActivationGradBuilder Builder;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS2326 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
2327 return ActivationGradTypeTable();
2328 }
2329 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2330 VT_TYPE = 4,
2331 VT_ALPHA = 6
2332 };
typeFLATBUFFERS_FINAL_CLASS2333 mindspore::schema::v0::ActivationType type() const {
2334 return static_cast<mindspore::schema::v0::ActivationType>(GetField<int8_t>(VT_TYPE, 0));
2335 }
mutate_typeFLATBUFFERS_FINAL_CLASS2336 bool mutate_type(mindspore::schema::v0::ActivationType _type) {
2337 return SetField<int8_t>(VT_TYPE, static_cast<int8_t>(_type), 0);
2338 }
alphaFLATBUFFERS_FINAL_CLASS2339 float alpha() const {
2340 return GetField<float>(VT_ALPHA, 0.2f);
2341 }
mutate_alphaFLATBUFFERS_FINAL_CLASS2342 bool mutate_alpha(float _alpha) {
2343 return SetField<float>(VT_ALPHA, _alpha, 0.2f);
2344 }
VerifyFLATBUFFERS_FINAL_CLASS2345 bool Verify(flatbuffers::Verifier &verifier) const {
2346 return VerifyTableStart(verifier) &&
2347 VerifyField<int8_t>(verifier, VT_TYPE) &&
2348 VerifyField<float>(verifier, VT_ALPHA) &&
2349 verifier.EndTable();
2350 }
2351 ActivationGradT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2352 void UnPackTo(ActivationGradT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2353 static flatbuffers::Offset<ActivationGrad> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ActivationGradT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2354 };
2355
2356 struct ActivationGradBuilder {
2357 typedef ActivationGrad Table;
2358 flatbuffers::FlatBufferBuilder &fbb_;
2359 flatbuffers::uoffset_t start_;
add_typeActivationGradBuilder2360 void add_type(mindspore::schema::v0::ActivationType type) {
2361 fbb_.AddElement<int8_t>(ActivationGrad::VT_TYPE, static_cast<int8_t>(type), 0);
2362 }
add_alphaActivationGradBuilder2363 void add_alpha(float alpha) {
2364 fbb_.AddElement<float>(ActivationGrad::VT_ALPHA, alpha, 0.2f);
2365 }
ActivationGradBuilderActivationGradBuilder2366 explicit ActivationGradBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2367 : fbb_(_fbb) {
2368 start_ = fbb_.StartTable();
2369 }
FinishActivationGradBuilder2370 flatbuffers::Offset<ActivationGrad> Finish() {
2371 const auto end = fbb_.EndTable(start_);
2372 auto o = flatbuffers::Offset<ActivationGrad>(end);
2373 return o;
2374 }
2375 };
2376
2377 inline flatbuffers::Offset<ActivationGrad> CreateActivationGrad(
2378 flatbuffers::FlatBufferBuilder &_fbb,
2379 mindspore::schema::v0::ActivationType type = mindspore::schema::v0::ActivationType_NO_ACTIVATION,
2380 float alpha = 0.2f) {
2381 ActivationGradBuilder builder_(_fbb);
2382 builder_.add_alpha(alpha);
2383 builder_.add_type(type);
2384 return builder_.Finish();
2385 }
2386
2387 flatbuffers::Offset<ActivationGrad> CreateActivationGrad(flatbuffers::FlatBufferBuilder &_fbb, const ActivationGradT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2388
2389 struct Conv2DT : public flatbuffers::NativeTable {
2390 typedef Conv2D TableType;
2391 mindspore::schema::v0::Format format = mindspore::schema::v0::Format_NCHW;
2392 int32_t group = 0;
2393 int32_t channelIn = 0;
2394 int32_t channelOut = 0;
2395 int32_t kernelW = 0;
2396 int32_t kernelH = 0;
2397 int32_t strideW = 0;
2398 int32_t strideH = 0;
2399 mindspore::schema::v0::PadMode padMode = mindspore::schema::v0::PadMode_NOTSET;
2400 int32_t padUp = 0;
2401 int32_t padDown = 0;
2402 int32_t padLeft = 0;
2403 int32_t padRight = 0;
2404 int32_t dilateW = 0;
2405 int32_t dilateH = 0;
2406 bool hasBias = false;
2407 mindspore::schema::v0::ActivationType activationType = mindspore::schema::v0::ActivationType_NO_ACTIVATION;
2408 };
2409
2410 struct Conv2D FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2411 typedef Conv2DT NativeTableType;
2412 typedef Conv2DBuilder Builder;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS2413 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
2414 return Conv2DTypeTable();
2415 }
2416 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2417 VT_FORMAT = 4,
2418 VT_GROUP = 6,
2419 VT_CHANNELIN = 8,
2420 VT_CHANNELOUT = 10,
2421 VT_KERNELW = 12,
2422 VT_KERNELH = 14,
2423 VT_STRIDEW = 16,
2424 VT_STRIDEH = 18,
2425 VT_PADMODE = 20,
2426 VT_PADUP = 22,
2427 VT_PADDOWN = 24,
2428 VT_PADLEFT = 26,
2429 VT_PADRIGHT = 28,
2430 VT_DILATEW = 30,
2431 VT_DILATEH = 32,
2432 VT_HASBIAS = 34,
2433 VT_ACTIVATIONTYPE = 36
2434 };
formatFLATBUFFERS_FINAL_CLASS2435 mindspore::schema::v0::Format format() const {
2436 return static_cast<mindspore::schema::v0::Format>(GetField<int32_t>(VT_FORMAT, 0));
2437 }
mutate_formatFLATBUFFERS_FINAL_CLASS2438 bool mutate_format(mindspore::schema::v0::Format _format) {
2439 return SetField<int32_t>(VT_FORMAT, static_cast<int32_t>(_format), 0);
2440 }
groupFLATBUFFERS_FINAL_CLASS2441 int32_t group() const {
2442 return GetField<int32_t>(VT_GROUP, 0);
2443 }
mutate_groupFLATBUFFERS_FINAL_CLASS2444 bool mutate_group(int32_t _group) {
2445 return SetField<int32_t>(VT_GROUP, _group, 0);
2446 }
channelInFLATBUFFERS_FINAL_CLASS2447 int32_t channelIn() const {
2448 return GetField<int32_t>(VT_CHANNELIN, 0);
2449 }
mutate_channelInFLATBUFFERS_FINAL_CLASS2450 bool mutate_channelIn(int32_t _channelIn) {
2451 return SetField<int32_t>(VT_CHANNELIN, _channelIn, 0);
2452 }
channelOutFLATBUFFERS_FINAL_CLASS2453 int32_t channelOut() const {
2454 return GetField<int32_t>(VT_CHANNELOUT, 0);
2455 }
mutate_channelOutFLATBUFFERS_FINAL_CLASS2456 bool mutate_channelOut(int32_t _channelOut) {
2457 return SetField<int32_t>(VT_CHANNELOUT, _channelOut, 0);
2458 }
kernelWFLATBUFFERS_FINAL_CLASS2459 int32_t kernelW() const {
2460 return GetField<int32_t>(VT_KERNELW, 0);
2461 }
mutate_kernelWFLATBUFFERS_FINAL_CLASS2462 bool mutate_kernelW(int32_t _kernelW) {
2463 return SetField<int32_t>(VT_KERNELW, _kernelW, 0);
2464 }
kernelHFLATBUFFERS_FINAL_CLASS2465 int32_t kernelH() const {
2466 return GetField<int32_t>(VT_KERNELH, 0);
2467 }
mutate_kernelHFLATBUFFERS_FINAL_CLASS2468 bool mutate_kernelH(int32_t _kernelH) {
2469 return SetField<int32_t>(VT_KERNELH, _kernelH, 0);
2470 }
strideWFLATBUFFERS_FINAL_CLASS2471 int32_t strideW() const {
2472 return GetField<int32_t>(VT_STRIDEW, 0);
2473 }
mutate_strideWFLATBUFFERS_FINAL_CLASS2474 bool mutate_strideW(int32_t _strideW) {
2475 return SetField<int32_t>(VT_STRIDEW, _strideW, 0);
2476 }
strideHFLATBUFFERS_FINAL_CLASS2477 int32_t strideH() const {
2478 return GetField<int32_t>(VT_STRIDEH, 0);
2479 }
mutate_strideHFLATBUFFERS_FINAL_CLASS2480 bool mutate_strideH(int32_t _strideH) {
2481 return SetField<int32_t>(VT_STRIDEH, _strideH, 0);
2482 }
padModeFLATBUFFERS_FINAL_CLASS2483 mindspore::schema::v0::PadMode padMode() const {
2484 return static_cast<mindspore::schema::v0::PadMode>(GetField<int8_t>(VT_PADMODE, 0));
2485 }
mutate_padModeFLATBUFFERS_FINAL_CLASS2486 bool mutate_padMode(mindspore::schema::v0::PadMode _padMode) {
2487 return SetField<int8_t>(VT_PADMODE, static_cast<int8_t>(_padMode), 0);
2488 }
padUpFLATBUFFERS_FINAL_CLASS2489 int32_t padUp() const {
2490 return GetField<int32_t>(VT_PADUP, 0);
2491 }
mutate_padUpFLATBUFFERS_FINAL_CLASS2492 bool mutate_padUp(int32_t _padUp) {
2493 return SetField<int32_t>(VT_PADUP, _padUp, 0);
2494 }
padDownFLATBUFFERS_FINAL_CLASS2495 int32_t padDown() const {
2496 return GetField<int32_t>(VT_PADDOWN, 0);
2497 }
mutate_padDownFLATBUFFERS_FINAL_CLASS2498 bool mutate_padDown(int32_t _padDown) {
2499 return SetField<int32_t>(VT_PADDOWN, _padDown, 0);
2500 }
padLeftFLATBUFFERS_FINAL_CLASS2501 int32_t padLeft() const {
2502 return GetField<int32_t>(VT_PADLEFT, 0);
2503 }
mutate_padLeftFLATBUFFERS_FINAL_CLASS2504 bool mutate_padLeft(int32_t _padLeft) {
2505 return SetField<int32_t>(VT_PADLEFT, _padLeft, 0);
2506 }
padRightFLATBUFFERS_FINAL_CLASS2507 int32_t padRight() const {
2508 return GetField<int32_t>(VT_PADRIGHT, 0);
2509 }
mutate_padRightFLATBUFFERS_FINAL_CLASS2510 bool mutate_padRight(int32_t _padRight) {
2511 return SetField<int32_t>(VT_PADRIGHT, _padRight, 0);
2512 }
dilateWFLATBUFFERS_FINAL_CLASS2513 int32_t dilateW() const {
2514 return GetField<int32_t>(VT_DILATEW, 0);
2515 }
mutate_dilateWFLATBUFFERS_FINAL_CLASS2516 bool mutate_dilateW(int32_t _dilateW) {
2517 return SetField<int32_t>(VT_DILATEW, _dilateW, 0);
2518 }
dilateHFLATBUFFERS_FINAL_CLASS2519 int32_t dilateH() const {
2520 return GetField<int32_t>(VT_DILATEH, 0);
2521 }
mutate_dilateHFLATBUFFERS_FINAL_CLASS2522 bool mutate_dilateH(int32_t _dilateH) {
2523 return SetField<int32_t>(VT_DILATEH, _dilateH, 0);
2524 }
hasBiasFLATBUFFERS_FINAL_CLASS2525 bool hasBias() const {
2526 return GetField<uint8_t>(VT_HASBIAS, 0) != 0;
2527 }
mutate_hasBiasFLATBUFFERS_FINAL_CLASS2528 bool mutate_hasBias(bool _hasBias) {
2529 return SetField<uint8_t>(VT_HASBIAS, static_cast<uint8_t>(_hasBias), 0);
2530 }
activationTypeFLATBUFFERS_FINAL_CLASS2531 mindspore::schema::v0::ActivationType activationType() const {
2532 return static_cast<mindspore::schema::v0::ActivationType>(GetField<int8_t>(VT_ACTIVATIONTYPE, 0));
2533 }
mutate_activationTypeFLATBUFFERS_FINAL_CLASS2534 bool mutate_activationType(mindspore::schema::v0::ActivationType _activationType) {
2535 return SetField<int8_t>(VT_ACTIVATIONTYPE, static_cast<int8_t>(_activationType), 0);
2536 }
VerifyFLATBUFFERS_FINAL_CLASS2537 bool Verify(flatbuffers::Verifier &verifier) const {
2538 return VerifyTableStart(verifier) &&
2539 VerifyField<int32_t>(verifier, VT_FORMAT) &&
2540 VerifyField<int32_t>(verifier, VT_GROUP) &&
2541 VerifyField<int32_t>(verifier, VT_CHANNELIN) &&
2542 VerifyField<int32_t>(verifier, VT_CHANNELOUT) &&
2543 VerifyField<int32_t>(verifier, VT_KERNELW) &&
2544 VerifyField<int32_t>(verifier, VT_KERNELH) &&
2545 VerifyField<int32_t>(verifier, VT_STRIDEW) &&
2546 VerifyField<int32_t>(verifier, VT_STRIDEH) &&
2547 VerifyField<int8_t>(verifier, VT_PADMODE) &&
2548 VerifyField<int32_t>(verifier, VT_PADUP) &&
2549 VerifyField<int32_t>(verifier, VT_PADDOWN) &&
2550 VerifyField<int32_t>(verifier, VT_PADLEFT) &&
2551 VerifyField<int32_t>(verifier, VT_PADRIGHT) &&
2552 VerifyField<int32_t>(verifier, VT_DILATEW) &&
2553 VerifyField<int32_t>(verifier, VT_DILATEH) &&
2554 VerifyField<uint8_t>(verifier, VT_HASBIAS) &&
2555 VerifyField<int8_t>(verifier, VT_ACTIVATIONTYPE) &&
2556 verifier.EndTable();
2557 }
2558 Conv2DT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2559 void UnPackTo(Conv2DT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2560 static flatbuffers::Offset<Conv2D> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2561 };
2562
2563 struct Conv2DBuilder {
2564 typedef Conv2D Table;
2565 flatbuffers::FlatBufferBuilder &fbb_;
2566 flatbuffers::uoffset_t start_;
add_formatConv2DBuilder2567 void add_format(mindspore::schema::v0::Format format) {
2568 fbb_.AddElement<int32_t>(Conv2D::VT_FORMAT, static_cast<int32_t>(format), 0);
2569 }
add_groupConv2DBuilder2570 void add_group(int32_t group) {
2571 fbb_.AddElement<int32_t>(Conv2D::VT_GROUP, group, 0);
2572 }
add_channelInConv2DBuilder2573 void add_channelIn(int32_t channelIn) {
2574 fbb_.AddElement<int32_t>(Conv2D::VT_CHANNELIN, channelIn, 0);
2575 }
add_channelOutConv2DBuilder2576 void add_channelOut(int32_t channelOut) {
2577 fbb_.AddElement<int32_t>(Conv2D::VT_CHANNELOUT, channelOut, 0);
2578 }
add_kernelWConv2DBuilder2579 void add_kernelW(int32_t kernelW) {
2580 fbb_.AddElement<int32_t>(Conv2D::VT_KERNELW, kernelW, 0);
2581 }
add_kernelHConv2DBuilder2582 void add_kernelH(int32_t kernelH) {
2583 fbb_.AddElement<int32_t>(Conv2D::VT_KERNELH, kernelH, 0);
2584 }
add_strideWConv2DBuilder2585 void add_strideW(int32_t strideW) {
2586 fbb_.AddElement<int32_t>(Conv2D::VT_STRIDEW, strideW, 0);
2587 }
add_strideHConv2DBuilder2588 void add_strideH(int32_t strideH) {
2589 fbb_.AddElement<int32_t>(Conv2D::VT_STRIDEH, strideH, 0);
2590 }
add_padModeConv2DBuilder2591 void add_padMode(mindspore::schema::v0::PadMode padMode) {
2592 fbb_.AddElement<int8_t>(Conv2D::VT_PADMODE, static_cast<int8_t>(padMode), 0);
2593 }
add_padUpConv2DBuilder2594 void add_padUp(int32_t padUp) {
2595 fbb_.AddElement<int32_t>(Conv2D::VT_PADUP, padUp, 0);
2596 }
add_padDownConv2DBuilder2597 void add_padDown(int32_t padDown) {
2598 fbb_.AddElement<int32_t>(Conv2D::VT_PADDOWN, padDown, 0);
2599 }
add_padLeftConv2DBuilder2600 void add_padLeft(int32_t padLeft) {
2601 fbb_.AddElement<int32_t>(Conv2D::VT_PADLEFT, padLeft, 0);
2602 }
add_padRightConv2DBuilder2603 void add_padRight(int32_t padRight) {
2604 fbb_.AddElement<int32_t>(Conv2D::VT_PADRIGHT, padRight, 0);
2605 }
add_dilateWConv2DBuilder2606 void add_dilateW(int32_t dilateW) {
2607 fbb_.AddElement<int32_t>(Conv2D::VT_DILATEW, dilateW, 0);
2608 }
add_dilateHConv2DBuilder2609 void add_dilateH(int32_t dilateH) {
2610 fbb_.AddElement<int32_t>(Conv2D::VT_DILATEH, dilateH, 0);
2611 }
add_hasBiasConv2DBuilder2612 void add_hasBias(bool hasBias) {
2613 fbb_.AddElement<uint8_t>(Conv2D::VT_HASBIAS, static_cast<uint8_t>(hasBias), 0);
2614 }
add_activationTypeConv2DBuilder2615 void add_activationType(mindspore::schema::v0::ActivationType activationType) {
2616 fbb_.AddElement<int8_t>(Conv2D::VT_ACTIVATIONTYPE, static_cast<int8_t>(activationType), 0);
2617 }
Conv2DBuilderConv2DBuilder2618 explicit Conv2DBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2619 : fbb_(_fbb) {
2620 start_ = fbb_.StartTable();
2621 }
FinishConv2DBuilder2622 flatbuffers::Offset<Conv2D> Finish() {
2623 const auto end = fbb_.EndTable(start_);
2624 auto o = flatbuffers::Offset<Conv2D>(end);
2625 return o;
2626 }
2627 };
2628
2629 inline flatbuffers::Offset<Conv2D> CreateConv2D(
2630 flatbuffers::FlatBufferBuilder &_fbb,
2631 mindspore::schema::v0::Format format = mindspore::schema::v0::Format_NCHW,
2632 int32_t group = 0,
2633 int32_t channelIn = 0,
2634 int32_t channelOut = 0,
2635 int32_t kernelW = 0,
2636 int32_t kernelH = 0,
2637 int32_t strideW = 0,
2638 int32_t strideH = 0,
2639 mindspore::schema::v0::PadMode padMode = mindspore::schema::v0::PadMode_NOTSET,
2640 int32_t padUp = 0,
2641 int32_t padDown = 0,
2642 int32_t padLeft = 0,
2643 int32_t padRight = 0,
2644 int32_t dilateW = 0,
2645 int32_t dilateH = 0,
2646 bool hasBias = false,
2647 mindspore::schema::v0::ActivationType activationType = mindspore::schema::v0::ActivationType_NO_ACTIVATION) {
2648 Conv2DBuilder builder_(_fbb);
2649 builder_.add_dilateH(dilateH);
2650 builder_.add_dilateW(dilateW);
2651 builder_.add_padRight(padRight);
2652 builder_.add_padLeft(padLeft);
2653 builder_.add_padDown(padDown);
2654 builder_.add_padUp(padUp);
2655 builder_.add_strideH(strideH);
2656 builder_.add_strideW(strideW);
2657 builder_.add_kernelH(kernelH);
2658 builder_.add_kernelW(kernelW);
2659 builder_.add_channelOut(channelOut);
2660 builder_.add_channelIn(channelIn);
2661 builder_.add_group(group);
2662 builder_.add_format(format);
2663 builder_.add_activationType(activationType);
2664 builder_.add_hasBias(hasBias);
2665 builder_.add_padMode(padMode);
2666 return builder_.Finish();
2667 }
2668
2669 flatbuffers::Offset<Conv2D> CreateConv2D(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2670
2671 struct AdderT : public flatbuffers::NativeTable {
2672 typedef Adder TableType;
2673 mindspore::schema::v0::Format format = mindspore::schema::v0::Format_NCHW;
2674 int32_t group = 0;
2675 int32_t channelIn = 0;
2676 int32_t channelOut = 0;
2677 int32_t kernelW = 0;
2678 int32_t kernelH = 0;
2679 int32_t strideW = 0;
2680 int32_t strideH = 0;
2681 mindspore::schema::v0::PadMode padMode = mindspore::schema::v0::PadMode_NOTSET;
2682 int32_t padUp = 0;
2683 int32_t padDown = 0;
2684 int32_t padLeft = 0;
2685 int32_t padRight = 0;
2686 int32_t dilateW = 0;
2687 int32_t dilateH = 0;
2688 bool hasBias = false;
2689 mindspore::schema::v0::ActivationType activationType = mindspore::schema::v0::ActivationType_NO_ACTIVATION;
2690 };
2691
2692 struct Adder FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2693 typedef AdderT NativeTableType;
2694 typedef AdderBuilder Builder;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS2695 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
2696 return AdderTypeTable();
2697 }
2698 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2699 VT_FORMAT = 4,
2700 VT_GROUP = 6,
2701 VT_CHANNELIN = 8,
2702 VT_CHANNELOUT = 10,
2703 VT_KERNELW = 12,
2704 VT_KERNELH = 14,
2705 VT_STRIDEW = 16,
2706 VT_STRIDEH = 18,
2707 VT_PADMODE = 20,
2708 VT_PADUP = 22,
2709 VT_PADDOWN = 24,
2710 VT_PADLEFT = 26,
2711 VT_PADRIGHT = 28,
2712 VT_DILATEW = 30,
2713 VT_DILATEH = 32,
2714 VT_HASBIAS = 34,
2715 VT_ACTIVATIONTYPE = 36
2716 };
formatFLATBUFFERS_FINAL_CLASS2717 mindspore::schema::v0::Format format() const {
2718 return static_cast<mindspore::schema::v0::Format>(GetField<int32_t>(VT_FORMAT, 0));
2719 }
mutate_formatFLATBUFFERS_FINAL_CLASS2720 bool mutate_format(mindspore::schema::v0::Format _format) {
2721 return SetField<int32_t>(VT_FORMAT, static_cast<int32_t>(_format), 0);
2722 }
groupFLATBUFFERS_FINAL_CLASS2723 int32_t group() const {
2724 return GetField<int32_t>(VT_GROUP, 0);
2725 }
mutate_groupFLATBUFFERS_FINAL_CLASS2726 bool mutate_group(int32_t _group) {
2727 return SetField<int32_t>(VT_GROUP, _group, 0);
2728 }
channelInFLATBUFFERS_FINAL_CLASS2729 int32_t channelIn() const {
2730 return GetField<int32_t>(VT_CHANNELIN, 0);
2731 }
mutate_channelInFLATBUFFERS_FINAL_CLASS2732 bool mutate_channelIn(int32_t _channelIn) {
2733 return SetField<int32_t>(VT_CHANNELIN, _channelIn, 0);
2734 }
channelOutFLATBUFFERS_FINAL_CLASS2735 int32_t channelOut() const {
2736 return GetField<int32_t>(VT_CHANNELOUT, 0);
2737 }
mutate_channelOutFLATBUFFERS_FINAL_CLASS2738 bool mutate_channelOut(int32_t _channelOut) {
2739 return SetField<int32_t>(VT_CHANNELOUT, _channelOut, 0);
2740 }
kernelWFLATBUFFERS_FINAL_CLASS2741 int32_t kernelW() const {
2742 return GetField<int32_t>(VT_KERNELW, 0);
2743 }
mutate_kernelWFLATBUFFERS_FINAL_CLASS2744 bool mutate_kernelW(int32_t _kernelW) {
2745 return SetField<int32_t>(VT_KERNELW, _kernelW, 0);
2746 }
kernelHFLATBUFFERS_FINAL_CLASS2747 int32_t kernelH() const {
2748 return GetField<int32_t>(VT_KERNELH, 0);
2749 }
mutate_kernelHFLATBUFFERS_FINAL_CLASS2750 bool mutate_kernelH(int32_t _kernelH) {
2751 return SetField<int32_t>(VT_KERNELH, _kernelH, 0);
2752 }
strideWFLATBUFFERS_FINAL_CLASS2753 int32_t strideW() const {
2754 return GetField<int32_t>(VT_STRIDEW, 0);
2755 }
mutate_strideWFLATBUFFERS_FINAL_CLASS2756 bool mutate_strideW(int32_t _strideW) {
2757 return SetField<int32_t>(VT_STRIDEW, _strideW, 0);
2758 }
strideHFLATBUFFERS_FINAL_CLASS2759 int32_t strideH() const {
2760 return GetField<int32_t>(VT_STRIDEH, 0);
2761 }
mutate_strideHFLATBUFFERS_FINAL_CLASS2762 bool mutate_strideH(int32_t _strideH) {
2763 return SetField<int32_t>(VT_STRIDEH, _strideH, 0);
2764 }
padModeFLATBUFFERS_FINAL_CLASS2765 mindspore::schema::v0::PadMode padMode() const {
2766 return static_cast<mindspore::schema::v0::PadMode>(GetField<int8_t>(VT_PADMODE, 0));
2767 }
mutate_padModeFLATBUFFERS_FINAL_CLASS2768 bool mutate_padMode(mindspore::schema::v0::PadMode _padMode) {
2769 return SetField<int8_t>(VT_PADMODE, static_cast<int8_t>(_padMode), 0);
2770 }
padUpFLATBUFFERS_FINAL_CLASS2771 int32_t padUp() const {
2772 return GetField<int32_t>(VT_PADUP, 0);
2773 }
mutate_padUpFLATBUFFERS_FINAL_CLASS2774 bool mutate_padUp(int32_t _padUp) {
2775 return SetField<int32_t>(VT_PADUP, _padUp, 0);
2776 }
padDownFLATBUFFERS_FINAL_CLASS2777 int32_t padDown() const {
2778 return GetField<int32_t>(VT_PADDOWN, 0);
2779 }
mutate_padDownFLATBUFFERS_FINAL_CLASS2780 bool mutate_padDown(int32_t _padDown) {
2781 return SetField<int32_t>(VT_PADDOWN, _padDown, 0);
2782 }
padLeftFLATBUFFERS_FINAL_CLASS2783 int32_t padLeft() const {
2784 return GetField<int32_t>(VT_PADLEFT, 0);
2785 }
mutate_padLeftFLATBUFFERS_FINAL_CLASS2786 bool mutate_padLeft(int32_t _padLeft) {
2787 return SetField<int32_t>(VT_PADLEFT, _padLeft, 0);
2788 }
padRightFLATBUFFERS_FINAL_CLASS2789 int32_t padRight() const {
2790 return GetField<int32_t>(VT_PADRIGHT, 0);
2791 }
mutate_padRightFLATBUFFERS_FINAL_CLASS2792 bool mutate_padRight(int32_t _padRight) {
2793 return SetField<int32_t>(VT_PADRIGHT, _padRight, 0);
2794 }
dilateWFLATBUFFERS_FINAL_CLASS2795 int32_t dilateW() const {
2796 return GetField<int32_t>(VT_DILATEW, 0);
2797 }
mutate_dilateWFLATBUFFERS_FINAL_CLASS2798 bool mutate_dilateW(int32_t _dilateW) {
2799 return SetField<int32_t>(VT_DILATEW, _dilateW, 0);
2800 }
dilateHFLATBUFFERS_FINAL_CLASS2801 int32_t dilateH() const {
2802 return GetField<int32_t>(VT_DILATEH, 0);
2803 }
mutate_dilateHFLATBUFFERS_FINAL_CLASS2804 bool mutate_dilateH(int32_t _dilateH) {
2805 return SetField<int32_t>(VT_DILATEH, _dilateH, 0);
2806 }
hasBiasFLATBUFFERS_FINAL_CLASS2807 bool hasBias() const {
2808 return GetField<uint8_t>(VT_HASBIAS, 0) != 0;
2809 }
mutate_hasBiasFLATBUFFERS_FINAL_CLASS2810 bool mutate_hasBias(bool _hasBias) {
2811 return SetField<uint8_t>(VT_HASBIAS, static_cast<uint8_t>(_hasBias), 0);
2812 }
activationTypeFLATBUFFERS_FINAL_CLASS2813 mindspore::schema::v0::ActivationType activationType() const {
2814 return static_cast<mindspore::schema::v0::ActivationType>(GetField<int8_t>(VT_ACTIVATIONTYPE, 0));
2815 }
mutate_activationTypeFLATBUFFERS_FINAL_CLASS2816 bool mutate_activationType(mindspore::schema::v0::ActivationType _activationType) {
2817 return SetField<int8_t>(VT_ACTIVATIONTYPE, static_cast<int8_t>(_activationType), 0);
2818 }
VerifyFLATBUFFERS_FINAL_CLASS2819 bool Verify(flatbuffers::Verifier &verifier) const {
2820 return VerifyTableStart(verifier) &&
2821 VerifyField<int32_t>(verifier, VT_FORMAT) &&
2822 VerifyField<int32_t>(verifier, VT_GROUP) &&
2823 VerifyField<int32_t>(verifier, VT_CHANNELIN) &&
2824 VerifyField<int32_t>(verifier, VT_CHANNELOUT) &&
2825 VerifyField<int32_t>(verifier, VT_KERNELW) &&
2826 VerifyField<int32_t>(verifier, VT_KERNELH) &&
2827 VerifyField<int32_t>(verifier, VT_STRIDEW) &&
2828 VerifyField<int32_t>(verifier, VT_STRIDEH) &&
2829 VerifyField<int8_t>(verifier, VT_PADMODE) &&
2830 VerifyField<int32_t>(verifier, VT_PADUP) &&
2831 VerifyField<int32_t>(verifier, VT_PADDOWN) &&
2832 VerifyField<int32_t>(verifier, VT_PADLEFT) &&
2833 VerifyField<int32_t>(verifier, VT_PADRIGHT) &&
2834 VerifyField<int32_t>(verifier, VT_DILATEW) &&
2835 VerifyField<int32_t>(verifier, VT_DILATEH) &&
2836 VerifyField<uint8_t>(verifier, VT_HASBIAS) &&
2837 VerifyField<int8_t>(verifier, VT_ACTIVATIONTYPE) &&
2838 verifier.EndTable();
2839 }
2840 AdderT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2841 void UnPackTo(AdderT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2842 static flatbuffers::Offset<Adder> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AdderT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2843 };
2844
2845 struct AdderBuilder {
2846 typedef Adder Table;
2847 flatbuffers::FlatBufferBuilder &fbb_;
2848 flatbuffers::uoffset_t start_;
add_formatAdderBuilder2849 void add_format(mindspore::schema::v0::Format format) {
2850 fbb_.AddElement<int32_t>(Adder::VT_FORMAT, static_cast<int32_t>(format), 0);
2851 }
add_groupAdderBuilder2852 void add_group(int32_t group) {
2853 fbb_.AddElement<int32_t>(Adder::VT_GROUP, group, 0);
2854 }
add_channelInAdderBuilder2855 void add_channelIn(int32_t channelIn) {
2856 fbb_.AddElement<int32_t>(Adder::VT_CHANNELIN, channelIn, 0);
2857 }
add_channelOutAdderBuilder2858 void add_channelOut(int32_t channelOut) {
2859 fbb_.AddElement<int32_t>(Adder::VT_CHANNELOUT, channelOut, 0);
2860 }
add_kernelWAdderBuilder2861 void add_kernelW(int32_t kernelW) {
2862 fbb_.AddElement<int32_t>(Adder::VT_KERNELW, kernelW, 0);
2863 }
add_kernelHAdderBuilder2864 void add_kernelH(int32_t kernelH) {
2865 fbb_.AddElement<int32_t>(Adder::VT_KERNELH, kernelH, 0);
2866 }
add_strideWAdderBuilder2867 void add_strideW(int32_t strideW) {
2868 fbb_.AddElement<int32_t>(Adder::VT_STRIDEW, strideW, 0);
2869 }
add_strideHAdderBuilder2870 void add_strideH(int32_t strideH) {
2871 fbb_.AddElement<int32_t>(Adder::VT_STRIDEH, strideH, 0);
2872 }
add_padModeAdderBuilder2873 void add_padMode(mindspore::schema::v0::PadMode padMode) {
2874 fbb_.AddElement<int8_t>(Adder::VT_PADMODE, static_cast<int8_t>(padMode), 0);
2875 }
add_padUpAdderBuilder2876 void add_padUp(int32_t padUp) {
2877 fbb_.AddElement<int32_t>(Adder::VT_PADUP, padUp, 0);
2878 }
add_padDownAdderBuilder2879 void add_padDown(int32_t padDown) {
2880 fbb_.AddElement<int32_t>(Adder::VT_PADDOWN, padDown, 0);
2881 }
add_padLeftAdderBuilder2882 void add_padLeft(int32_t padLeft) {
2883 fbb_.AddElement<int32_t>(Adder::VT_PADLEFT, padLeft, 0);
2884 }
add_padRightAdderBuilder2885 void add_padRight(int32_t padRight) {
2886 fbb_.AddElement<int32_t>(Adder::VT_PADRIGHT, padRight, 0);
2887 }
add_dilateWAdderBuilder2888 void add_dilateW(int32_t dilateW) {
2889 fbb_.AddElement<int32_t>(Adder::VT_DILATEW, dilateW, 0);
2890 }
add_dilateHAdderBuilder2891 void add_dilateH(int32_t dilateH) {
2892 fbb_.AddElement<int32_t>(Adder::VT_DILATEH, dilateH, 0);
2893 }
add_hasBiasAdderBuilder2894 void add_hasBias(bool hasBias) {
2895 fbb_.AddElement<uint8_t>(Adder::VT_HASBIAS, static_cast<uint8_t>(hasBias), 0);
2896 }
add_activationTypeAdderBuilder2897 void add_activationType(mindspore::schema::v0::ActivationType activationType) {
2898 fbb_.AddElement<int8_t>(Adder::VT_ACTIVATIONTYPE, static_cast<int8_t>(activationType), 0);
2899 }
AdderBuilderAdderBuilder2900 explicit AdderBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2901 : fbb_(_fbb) {
2902 start_ = fbb_.StartTable();
2903 }
FinishAdderBuilder2904 flatbuffers::Offset<Adder> Finish() {
2905 const auto end = fbb_.EndTable(start_);
2906 auto o = flatbuffers::Offset<Adder>(end);
2907 return o;
2908 }
2909 };
2910
2911 inline flatbuffers::Offset<Adder> CreateAdder(
2912 flatbuffers::FlatBufferBuilder &_fbb,
2913 mindspore::schema::v0::Format format = mindspore::schema::v0::Format_NCHW,
2914 int32_t group = 0,
2915 int32_t channelIn = 0,
2916 int32_t channelOut = 0,
2917 int32_t kernelW = 0,
2918 int32_t kernelH = 0,
2919 int32_t strideW = 0,
2920 int32_t strideH = 0,
2921 mindspore::schema::v0::PadMode padMode = mindspore::schema::v0::PadMode_NOTSET,
2922 int32_t padUp = 0,
2923 int32_t padDown = 0,
2924 int32_t padLeft = 0,
2925 int32_t padRight = 0,
2926 int32_t dilateW = 0,
2927 int32_t dilateH = 0,
2928 bool hasBias = false,
2929 mindspore::schema::v0::ActivationType activationType = mindspore::schema::v0::ActivationType_NO_ACTIVATION) {
2930 AdderBuilder builder_(_fbb);
2931 builder_.add_dilateH(dilateH);
2932 builder_.add_dilateW(dilateW);
2933 builder_.add_padRight(padRight);
2934 builder_.add_padLeft(padLeft);
2935 builder_.add_padDown(padDown);
2936 builder_.add_padUp(padUp);
2937 builder_.add_strideH(strideH);
2938 builder_.add_strideW(strideW);
2939 builder_.add_kernelH(kernelH);
2940 builder_.add_kernelW(kernelW);
2941 builder_.add_channelOut(channelOut);
2942 builder_.add_channelIn(channelIn);
2943 builder_.add_group(group);
2944 builder_.add_format(format);
2945 builder_.add_activationType(activationType);
2946 builder_.add_hasBias(hasBias);
2947 builder_.add_padMode(padMode);
2948 return builder_.Finish();
2949 }
2950
2951 flatbuffers::Offset<Adder> CreateAdder(flatbuffers::FlatBufferBuilder &_fbb, const AdderT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2952
2953 struct Conv2DGradFilterT : public flatbuffers::NativeTable {
2954 typedef Conv2DGradFilter TableType;
2955 mindspore::schema::v0::Format format = mindspore::schema::v0::Format_NCHW;
2956 int32_t group = 0;
2957 int32_t channelIn = 0;
2958 int32_t channelOut = 0;
2959 int32_t kernelW = 0;
2960 int32_t kernelH = 0;
2961 int32_t strideW = 0;
2962 int32_t strideH = 0;
2963 mindspore::schema::v0::PadMode padMode = mindspore::schema::v0::PadMode_NOTSET;
2964 int32_t padUp = 0;
2965 int32_t padDown = 0;
2966 int32_t padLeft = 0;
2967 int32_t padRight = 0;
2968 int32_t dilateW = 0;
2969 int32_t dilateH = 0;
2970 bool hasBias = false;
2971 std::vector<int32_t> filter_shape{};
2972 mindspore::schema::v0::ActivationType activationType = mindspore::schema::v0::ActivationType_NO_ACTIVATION;
2973 };
2974
2975 struct Conv2DGradFilter FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2976 typedef Conv2DGradFilterT NativeTableType;
2977 typedef Conv2DGradFilterBuilder Builder;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS2978 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
2979 return Conv2DGradFilterTypeTable();
2980 }
2981 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2982 VT_FORMAT = 4,
2983 VT_GROUP = 6,
2984 VT_CHANNELIN = 8,
2985 VT_CHANNELOUT = 10,
2986 VT_KERNELW = 12,
2987 VT_KERNELH = 14,
2988 VT_STRIDEW = 16,
2989 VT_STRIDEH = 18,
2990 VT_PADMODE = 20,
2991 VT_PADUP = 22,
2992 VT_PADDOWN = 24,
2993 VT_PADLEFT = 26,
2994 VT_PADRIGHT = 28,
2995 VT_DILATEW = 30,
2996 VT_DILATEH = 32,
2997 VT_HASBIAS = 34,
2998 VT_FILTER_SHAPE = 36,
2999 VT_ACTIVATIONTYPE = 38
3000 };
formatFLATBUFFERS_FINAL_CLASS3001 mindspore::schema::v0::Format format() const {
3002 return static_cast<mindspore::schema::v0::Format>(GetField<int32_t>(VT_FORMAT, 0));
3003 }
mutate_formatFLATBUFFERS_FINAL_CLASS3004 bool mutate_format(mindspore::schema::v0::Format _format) {
3005 return SetField<int32_t>(VT_FORMAT, static_cast<int32_t>(_format), 0);
3006 }
groupFLATBUFFERS_FINAL_CLASS3007 int32_t group() const {
3008 return GetField<int32_t>(VT_GROUP, 0);
3009 }
mutate_groupFLATBUFFERS_FINAL_CLASS3010 bool mutate_group(int32_t _group) {
3011 return SetField<int32_t>(VT_GROUP, _group, 0);
3012 }
channelInFLATBUFFERS_FINAL_CLASS3013 int32_t channelIn() const {
3014 return GetField<int32_t>(VT_CHANNELIN, 0);
3015 }
mutate_channelInFLATBUFFERS_FINAL_CLASS3016 bool mutate_channelIn(int32_t _channelIn) {
3017 return SetField<int32_t>(VT_CHANNELIN, _channelIn, 0);
3018 }
channelOutFLATBUFFERS_FINAL_CLASS3019 int32_t channelOut() const {
3020 return GetField<int32_t>(VT_CHANNELOUT, 0);
3021 }
mutate_channelOutFLATBUFFERS_FINAL_CLASS3022 bool mutate_channelOut(int32_t _channelOut) {
3023 return SetField<int32_t>(VT_CHANNELOUT, _channelOut, 0);
3024 }
kernelWFLATBUFFERS_FINAL_CLASS3025 int32_t kernelW() const {
3026 return GetField<int32_t>(VT_KERNELW, 0);
3027 }
mutate_kernelWFLATBUFFERS_FINAL_CLASS3028 bool mutate_kernelW(int32_t _kernelW) {
3029 return SetField<int32_t>(VT_KERNELW, _kernelW, 0);
3030 }
kernelHFLATBUFFERS_FINAL_CLASS3031 int32_t kernelH() const {
3032 return GetField<int32_t>(VT_KERNELH, 0);
3033 }
mutate_kernelHFLATBUFFERS_FINAL_CLASS3034 bool mutate_kernelH(int32_t _kernelH) {
3035 return SetField<int32_t>(VT_KERNELH, _kernelH, 0);
3036 }
strideWFLATBUFFERS_FINAL_CLASS3037 int32_t strideW() const {
3038 return GetField<int32_t>(VT_STRIDEW, 0);
3039 }
mutate_strideWFLATBUFFERS_FINAL_CLASS3040 bool mutate_strideW(int32_t _strideW) {
3041 return SetField<int32_t>(VT_STRIDEW, _strideW, 0);
3042 }
strideHFLATBUFFERS_FINAL_CLASS3043 int32_t strideH() const {
3044 return GetField<int32_t>(VT_STRIDEH, 0);
3045 }
mutate_strideHFLATBUFFERS_FINAL_CLASS3046 bool mutate_strideH(int32_t _strideH) {
3047 return SetField<int32_t>(VT_STRIDEH, _strideH, 0);
3048 }
padModeFLATBUFFERS_FINAL_CLASS3049 mindspore::schema::v0::PadMode padMode() const {
3050 return static_cast<mindspore::schema::v0::PadMode>(GetField<int8_t>(VT_PADMODE, 0));
3051 }
mutate_padModeFLATBUFFERS_FINAL_CLASS3052 bool mutate_padMode(mindspore::schema::v0::PadMode _padMode) {
3053 return SetField<int8_t>(VT_PADMODE, static_cast<int8_t>(_padMode), 0);
3054 }
padUpFLATBUFFERS_FINAL_CLASS3055 int32_t padUp() const {
3056 return GetField<int32_t>(VT_PADUP, 0);
3057 }
mutate_padUpFLATBUFFERS_FINAL_CLASS3058 bool mutate_padUp(int32_t _padUp) {
3059 return SetField<int32_t>(VT_PADUP, _padUp, 0);
3060 }
padDownFLATBUFFERS_FINAL_CLASS3061 int32_t padDown() const {
3062 return GetField<int32_t>(VT_PADDOWN, 0);
3063 }
mutate_padDownFLATBUFFERS_FINAL_CLASS3064 bool mutate_padDown(int32_t _padDown) {
3065 return SetField<int32_t>(VT_PADDOWN, _padDown, 0);
3066 }
padLeftFLATBUFFERS_FINAL_CLASS3067 int32_t padLeft() const {
3068 return GetField<int32_t>(VT_PADLEFT, 0);
3069 }
mutate_padLeftFLATBUFFERS_FINAL_CLASS3070 bool mutate_padLeft(int32_t _padLeft) {
3071 return SetField<int32_t>(VT_PADLEFT, _padLeft, 0);
3072 }
padRightFLATBUFFERS_FINAL_CLASS3073 int32_t padRight() const {
3074 return GetField<int32_t>(VT_PADRIGHT, 0);
3075 }
mutate_padRightFLATBUFFERS_FINAL_CLASS3076 bool mutate_padRight(int32_t _padRight) {
3077 return SetField<int32_t>(VT_PADRIGHT, _padRight, 0);
3078 }
dilateWFLATBUFFERS_FINAL_CLASS3079 int32_t dilateW() const {
3080 return GetField<int32_t>(VT_DILATEW, 0);
3081 }
mutate_dilateWFLATBUFFERS_FINAL_CLASS3082 bool mutate_dilateW(int32_t _dilateW) {
3083 return SetField<int32_t>(VT_DILATEW, _dilateW, 0);
3084 }
dilateHFLATBUFFERS_FINAL_CLASS3085 int32_t dilateH() const {
3086 return GetField<int32_t>(VT_DILATEH, 0);
3087 }
mutate_dilateHFLATBUFFERS_FINAL_CLASS3088 bool mutate_dilateH(int32_t _dilateH) {
3089 return SetField<int32_t>(VT_DILATEH, _dilateH, 0);
3090 }
hasBiasFLATBUFFERS_FINAL_CLASS3091 bool hasBias() const {
3092 return GetField<uint8_t>(VT_HASBIAS, 0) != 0;
3093 }
mutate_hasBiasFLATBUFFERS_FINAL_CLASS3094 bool mutate_hasBias(bool _hasBias) {
3095 return SetField<uint8_t>(VT_HASBIAS, static_cast<uint8_t>(_hasBias), 0);
3096 }
filter_shapeFLATBUFFERS_FINAL_CLASS3097 const flatbuffers::Vector<int32_t> *filter_shape() const {
3098 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_FILTER_SHAPE);
3099 }
mutable_filter_shapeFLATBUFFERS_FINAL_CLASS3100 flatbuffers::Vector<int32_t> *mutable_filter_shape() {
3101 return GetPointer<flatbuffers::Vector<int32_t> *>(VT_FILTER_SHAPE);
3102 }
activationTypeFLATBUFFERS_FINAL_CLASS3103 mindspore::schema::v0::ActivationType activationType() const {
3104 return static_cast<mindspore::schema::v0::ActivationType>(GetField<int8_t>(VT_ACTIVATIONTYPE, 0));
3105 }
mutate_activationTypeFLATBUFFERS_FINAL_CLASS3106 bool mutate_activationType(mindspore::schema::v0::ActivationType _activationType) {
3107 return SetField<int8_t>(VT_ACTIVATIONTYPE, static_cast<int8_t>(_activationType), 0);
3108 }
VerifyFLATBUFFERS_FINAL_CLASS3109 bool Verify(flatbuffers::Verifier &verifier) const {
3110 return VerifyTableStart(verifier) &&
3111 VerifyField<int32_t>(verifier, VT_FORMAT) &&
3112 VerifyField<int32_t>(verifier, VT_GROUP) &&
3113 VerifyField<int32_t>(verifier, VT_CHANNELIN) &&
3114 VerifyField<int32_t>(verifier, VT_CHANNELOUT) &&
3115 VerifyField<int32_t>(verifier, VT_KERNELW) &&
3116 VerifyField<int32_t>(verifier, VT_KERNELH) &&
3117 VerifyField<int32_t>(verifier, VT_STRIDEW) &&
3118 VerifyField<int32_t>(verifier, VT_STRIDEH) &&
3119 VerifyField<int8_t>(verifier, VT_PADMODE) &&
3120 VerifyField<int32_t>(verifier, VT_PADUP) &&
3121 VerifyField<int32_t>(verifier, VT_PADDOWN) &&
3122 VerifyField<int32_t>(verifier, VT_PADLEFT) &&
3123 VerifyField<int32_t>(verifier, VT_PADRIGHT) &&
3124 VerifyField<int32_t>(verifier, VT_DILATEW) &&
3125 VerifyField<int32_t>(verifier, VT_DILATEH) &&
3126 VerifyField<uint8_t>(verifier, VT_HASBIAS) &&
3127 VerifyOffset(verifier, VT_FILTER_SHAPE) &&
3128 verifier.VerifyVector(filter_shape()) &&
3129 VerifyField<int8_t>(verifier, VT_ACTIVATIONTYPE) &&
3130 verifier.EndTable();
3131 }
3132 Conv2DGradFilterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3133 void UnPackTo(Conv2DGradFilterT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3134 static flatbuffers::Offset<Conv2DGradFilter> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DGradFilterT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3135 };
3136
3137 struct Conv2DGradFilterBuilder {
3138 typedef Conv2DGradFilter Table;
3139 flatbuffers::FlatBufferBuilder &fbb_;
3140 flatbuffers::uoffset_t start_;
add_formatConv2DGradFilterBuilder3141 void add_format(mindspore::schema::v0::Format format) {
3142 fbb_.AddElement<int32_t>(Conv2DGradFilter::VT_FORMAT, static_cast<int32_t>(format), 0);
3143 }
add_groupConv2DGradFilterBuilder3144 void add_group(int32_t group) {
3145 fbb_.AddElement<int32_t>(Conv2DGradFilter::VT_GROUP, group, 0);
3146 }
add_channelInConv2DGradFilterBuilder3147 void add_channelIn(int32_t channelIn) {
3148 fbb_.AddElement<int32_t>(Conv2DGradFilter::VT_CHANNELIN, channelIn, 0);
3149 }
add_channelOutConv2DGradFilterBuilder3150 void add_channelOut(int32_t channelOut) {
3151 fbb_.AddElement<int32_t>(Conv2DGradFilter::VT_CHANNELOUT, channelOut, 0);
3152 }
add_kernelWConv2DGradFilterBuilder3153 void add_kernelW(int32_t kernelW) {
3154 fbb_.AddElement<int32_t>(Conv2DGradFilter::VT_KERNELW, kernelW, 0);
3155 }
add_kernelHConv2DGradFilterBuilder3156 void add_kernelH(int32_t kernelH) {
3157 fbb_.AddElement<int32_t>(Conv2DGradFilter::VT_KERNELH, kernelH, 0);
3158 }
add_strideWConv2DGradFilterBuilder3159 void add_strideW(int32_t strideW) {
3160 fbb_.AddElement<int32_t>(Conv2DGradFilter::VT_STRIDEW, strideW, 0);
3161 }
add_strideHConv2DGradFilterBuilder3162 void add_strideH(int32_t strideH) {
3163 fbb_.AddElement<int32_t>(Conv2DGradFilter::VT_STRIDEH, strideH, 0);
3164 }
add_padModeConv2DGradFilterBuilder3165 void add_padMode(mindspore::schema::v0::PadMode padMode) {
3166 fbb_.AddElement<int8_t>(Conv2DGradFilter::VT_PADMODE, static_cast<int8_t>(padMode), 0);
3167 }
add_padUpConv2DGradFilterBuilder3168 void add_padUp(int32_t padUp) {
3169 fbb_.AddElement<int32_t>(Conv2DGradFilter::VT_PADUP, padUp, 0);
3170 }
add_padDownConv2DGradFilterBuilder3171 void add_padDown(int32_t padDown) {
3172 fbb_.AddElement<int32_t>(Conv2DGradFilter::VT_PADDOWN, padDown, 0);
3173 }
add_padLeftConv2DGradFilterBuilder3174 void add_padLeft(int32_t padLeft) {
3175 fbb_.AddElement<int32_t>(Conv2DGradFilter::VT_PADLEFT, padLeft, 0);
3176 }
add_padRightConv2DGradFilterBuilder3177 void add_padRight(int32_t padRight) {
3178 fbb_.AddElement<int32_t>(Conv2DGradFilter::VT_PADRIGHT, padRight, 0);
3179 }
add_dilateWConv2DGradFilterBuilder3180 void add_dilateW(int32_t dilateW) {
3181 fbb_.AddElement<int32_t>(Conv2DGradFilter::VT_DILATEW, dilateW, 0);
3182 }
add_dilateHConv2DGradFilterBuilder3183 void add_dilateH(int32_t dilateH) {
3184 fbb_.AddElement<int32_t>(Conv2DGradFilter::VT_DILATEH, dilateH, 0);
3185 }
add_hasBiasConv2DGradFilterBuilder3186 void add_hasBias(bool hasBias) {
3187 fbb_.AddElement<uint8_t>(Conv2DGradFilter::VT_HASBIAS, static_cast<uint8_t>(hasBias), 0);
3188 }
add_filter_shapeConv2DGradFilterBuilder3189 void add_filter_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> filter_shape) {
3190 fbb_.AddOffset(Conv2DGradFilter::VT_FILTER_SHAPE, filter_shape);
3191 }
add_activationTypeConv2DGradFilterBuilder3192 void add_activationType(mindspore::schema::v0::ActivationType activationType) {
3193 fbb_.AddElement<int8_t>(Conv2DGradFilter::VT_ACTIVATIONTYPE, static_cast<int8_t>(activationType), 0);
3194 }
Conv2DGradFilterBuilderConv2DGradFilterBuilder3195 explicit Conv2DGradFilterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3196 : fbb_(_fbb) {
3197 start_ = fbb_.StartTable();
3198 }
FinishConv2DGradFilterBuilder3199 flatbuffers::Offset<Conv2DGradFilter> Finish() {
3200 const auto end = fbb_.EndTable(start_);
3201 auto o = flatbuffers::Offset<Conv2DGradFilter>(end);
3202 return o;
3203 }
3204 };
3205
3206 inline flatbuffers::Offset<Conv2DGradFilter> CreateConv2DGradFilter(
3207 flatbuffers::FlatBufferBuilder &_fbb,
3208 mindspore::schema::v0::Format format = mindspore::schema::v0::Format_NCHW,
3209 int32_t group = 0,
3210 int32_t channelIn = 0,
3211 int32_t channelOut = 0,
3212 int32_t kernelW = 0,
3213 int32_t kernelH = 0,
3214 int32_t strideW = 0,
3215 int32_t strideH = 0,
3216 mindspore::schema::v0::PadMode padMode = mindspore::schema::v0::PadMode_NOTSET,
3217 int32_t padUp = 0,
3218 int32_t padDown = 0,
3219 int32_t padLeft = 0,
3220 int32_t padRight = 0,
3221 int32_t dilateW = 0,
3222 int32_t dilateH = 0,
3223 bool hasBias = false,
3224 flatbuffers::Offset<flatbuffers::Vector<int32_t>> filter_shape = 0,
3225 mindspore::schema::v0::ActivationType activationType = mindspore::schema::v0::ActivationType_NO_ACTIVATION) {
3226 Conv2DGradFilterBuilder builder_(_fbb);
3227 builder_.add_filter_shape(filter_shape);
3228 builder_.add_dilateH(dilateH);
3229 builder_.add_dilateW(dilateW);
3230 builder_.add_padRight(padRight);
3231 builder_.add_padLeft(padLeft);
3232 builder_.add_padDown(padDown);
3233 builder_.add_padUp(padUp);
3234 builder_.add_strideH(strideH);
3235 builder_.add_strideW(strideW);
3236 builder_.add_kernelH(kernelH);
3237 builder_.add_kernelW(kernelW);
3238 builder_.add_channelOut(channelOut);
3239 builder_.add_channelIn(channelIn);
3240 builder_.add_group(group);
3241 builder_.add_format(format);
3242 builder_.add_activationType(activationType);
3243 builder_.add_hasBias(hasBias);
3244 builder_.add_padMode(padMode);
3245 return builder_.Finish();
3246 }
3247
3248 inline flatbuffers::Offset<Conv2DGradFilter> CreateConv2DGradFilterDirect(
3249 flatbuffers::FlatBufferBuilder &_fbb,
3250 mindspore::schema::v0::Format format = mindspore::schema::v0::Format_NCHW,
3251 int32_t group = 0,
3252 int32_t channelIn = 0,
3253 int32_t channelOut = 0,
3254 int32_t kernelW = 0,
3255 int32_t kernelH = 0,
3256 int32_t strideW = 0,
3257 int32_t strideH = 0,
3258 mindspore::schema::v0::PadMode padMode = mindspore::schema::v0::PadMode_NOTSET,
3259 int32_t padUp = 0,
3260 int32_t padDown = 0,
3261 int32_t padLeft = 0,
3262 int32_t padRight = 0,
3263 int32_t dilateW = 0,
3264 int32_t dilateH = 0,
3265 bool hasBias = false,
3266 const std::vector<int32_t> *filter_shape = nullptr,
3267 mindspore::schema::v0::ActivationType activationType = mindspore::schema::v0::ActivationType_NO_ACTIVATION) {
3268 auto filter_shape__ = filter_shape ? _fbb.CreateVector<int32_t>(*filter_shape) : 0;
3269 return mindspore::schema::v0::CreateConv2DGradFilter(
3270 _fbb,
3271 format,
3272 group,
3273 channelIn,
3274 channelOut,
3275 kernelW,
3276 kernelH,
3277 strideW,
3278 strideH,
3279 padMode,
3280 padUp,
3281 padDown,
3282 padLeft,
3283 padRight,
3284 dilateW,
3285 dilateH,
3286 hasBias,
3287 filter_shape__,
3288 activationType);
3289 }
3290
3291 flatbuffers::Offset<Conv2DGradFilter> CreateConv2DGradFilter(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DGradFilterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3292
3293 struct Conv2DGradInputT : public flatbuffers::NativeTable {
3294 typedef Conv2DGradInput TableType;
3295 mindspore::schema::v0::Format format = mindspore::schema::v0::Format_NCHW;
3296 int32_t group = 0;
3297 int32_t channelIn = 0;
3298 int32_t channelOut = 0;
3299 int32_t kernelW = 0;
3300 int32_t kernelH = 0;
3301 int32_t strideW = 0;
3302 int32_t strideH = 0;
3303 mindspore::schema::v0::PadMode padMode = mindspore::schema::v0::PadMode_NOTSET;
3304 int32_t padUp = 0;
3305 int32_t padDown = 0;
3306 int32_t padLeft = 0;
3307 int32_t padRight = 0;
3308 int32_t dilateW = 0;
3309 int32_t dilateH = 0;
3310 bool hasBias = false;
3311 std::vector<int32_t> input_shape{};
3312 mindspore::schema::v0::ActivationType activationType = mindspore::schema::v0::ActivationType_NO_ACTIVATION;
3313 };
3314
3315 struct Conv2DGradInput FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3316 typedef Conv2DGradInputT NativeTableType;
3317 typedef Conv2DGradInputBuilder Builder;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS3318 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
3319 return Conv2DGradInputTypeTable();
3320 }
3321 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3322 VT_FORMAT = 4,
3323 VT_GROUP = 6,
3324 VT_CHANNELIN = 8,
3325 VT_CHANNELOUT = 10,
3326 VT_KERNELW = 12,
3327 VT_KERNELH = 14,
3328 VT_STRIDEW = 16,
3329 VT_STRIDEH = 18,
3330 VT_PADMODE = 20,
3331 VT_PADUP = 22,
3332 VT_PADDOWN = 24,
3333 VT_PADLEFT = 26,
3334 VT_PADRIGHT = 28,
3335 VT_DILATEW = 30,
3336 VT_DILATEH = 32,
3337 VT_HASBIAS = 34,
3338 VT_INPUT_SHAPE = 36,
3339 VT_ACTIVATIONTYPE = 38
3340 };
formatFLATBUFFERS_FINAL_CLASS3341 mindspore::schema::v0::Format format() const {
3342 return static_cast<mindspore::schema::v0::Format>(GetField<int32_t>(VT_FORMAT, 0));
3343 }
mutate_formatFLATBUFFERS_FINAL_CLASS3344 bool mutate_format(mindspore::schema::v0::Format _format) {
3345 return SetField<int32_t>(VT_FORMAT, static_cast<int32_t>(_format), 0);
3346 }
groupFLATBUFFERS_FINAL_CLASS3347 int32_t group() const {
3348 return GetField<int32_t>(VT_GROUP, 0);
3349 }
mutate_groupFLATBUFFERS_FINAL_CLASS3350 bool mutate_group(int32_t _group) {
3351 return SetField<int32_t>(VT_GROUP, _group, 0);
3352 }
channelInFLATBUFFERS_FINAL_CLASS3353 int32_t channelIn() const {
3354 return GetField<int32_t>(VT_CHANNELIN, 0);
3355 }
mutate_channelInFLATBUFFERS_FINAL_CLASS3356 bool mutate_channelIn(int32_t _channelIn) {
3357 return SetField<int32_t>(VT_CHANNELIN, _channelIn, 0);
3358 }
channelOutFLATBUFFERS_FINAL_CLASS3359 int32_t channelOut() const {
3360 return GetField<int32_t>(VT_CHANNELOUT, 0);
3361 }
mutate_channelOutFLATBUFFERS_FINAL_CLASS3362 bool mutate_channelOut(int32_t _channelOut) {
3363 return SetField<int32_t>(VT_CHANNELOUT, _channelOut, 0);
3364 }
kernelWFLATBUFFERS_FINAL_CLASS3365 int32_t kernelW() const {
3366 return GetField<int32_t>(VT_KERNELW, 0);
3367 }
mutate_kernelWFLATBUFFERS_FINAL_CLASS3368 bool mutate_kernelW(int32_t _kernelW) {
3369 return SetField<int32_t>(VT_KERNELW, _kernelW, 0);
3370 }
kernelHFLATBUFFERS_FINAL_CLASS3371 int32_t kernelH() const {
3372 return GetField<int32_t>(VT_KERNELH, 0);
3373 }
mutate_kernelHFLATBUFFERS_FINAL_CLASS3374 bool mutate_kernelH(int32_t _kernelH) {
3375 return SetField<int32_t>(VT_KERNELH, _kernelH, 0);
3376 }
strideWFLATBUFFERS_FINAL_CLASS3377 int32_t strideW() const {
3378 return GetField<int32_t>(VT_STRIDEW, 0);
3379 }
mutate_strideWFLATBUFFERS_FINAL_CLASS3380 bool mutate_strideW(int32_t _strideW) {
3381 return SetField<int32_t>(VT_STRIDEW, _strideW, 0);
3382 }
strideHFLATBUFFERS_FINAL_CLASS3383 int32_t strideH() const {
3384 return GetField<int32_t>(VT_STRIDEH, 0);
3385 }
mutate_strideHFLATBUFFERS_FINAL_CLASS3386 bool mutate_strideH(int32_t _strideH) {
3387 return SetField<int32_t>(VT_STRIDEH, _strideH, 0);
3388 }
padModeFLATBUFFERS_FINAL_CLASS3389 mindspore::schema::v0::PadMode padMode() const {
3390 return static_cast<mindspore::schema::v0::PadMode>(GetField<int8_t>(VT_PADMODE, 0));
3391 }
mutate_padModeFLATBUFFERS_FINAL_CLASS3392 bool mutate_padMode(mindspore::schema::v0::PadMode _padMode) {
3393 return SetField<int8_t>(VT_PADMODE, static_cast<int8_t>(_padMode), 0);
3394 }
padUpFLATBUFFERS_FINAL_CLASS3395 int32_t padUp() const {
3396 return GetField<int32_t>(VT_PADUP, 0);
3397 }
mutate_padUpFLATBUFFERS_FINAL_CLASS3398 bool mutate_padUp(int32_t _padUp) {
3399 return SetField<int32_t>(VT_PADUP, _padUp, 0);
3400 }
padDownFLATBUFFERS_FINAL_CLASS3401 int32_t padDown() const {
3402 return GetField<int32_t>(VT_PADDOWN, 0);
3403 }
mutate_padDownFLATBUFFERS_FINAL_CLASS3404 bool mutate_padDown(int32_t _padDown) {
3405 return SetField<int32_t>(VT_PADDOWN, _padDown, 0);
3406 }
padLeftFLATBUFFERS_FINAL_CLASS3407 int32_t padLeft() const {
3408 return GetField<int32_t>(VT_PADLEFT, 0);
3409 }
mutate_padLeftFLATBUFFERS_FINAL_CLASS3410 bool mutate_padLeft(int32_t _padLeft) {
3411 return SetField<int32_t>(VT_PADLEFT, _padLeft, 0);
3412 }
padRightFLATBUFFERS_FINAL_CLASS3413 int32_t padRight() const {
3414 return GetField<int32_t>(VT_PADRIGHT, 0);
3415 }
mutate_padRightFLATBUFFERS_FINAL_CLASS3416 bool mutate_padRight(int32_t _padRight) {
3417 return SetField<int32_t>(VT_PADRIGHT, _padRight, 0);
3418 }
dilateWFLATBUFFERS_FINAL_CLASS3419 int32_t dilateW() const {
3420 return GetField<int32_t>(VT_DILATEW, 0);
3421 }
mutate_dilateWFLATBUFFERS_FINAL_CLASS3422 bool mutate_dilateW(int32_t _dilateW) {
3423 return SetField<int32_t>(VT_DILATEW, _dilateW, 0);
3424 }
dilateHFLATBUFFERS_FINAL_CLASS3425 int32_t dilateH() const {
3426 return GetField<int32_t>(VT_DILATEH, 0);
3427 }
mutate_dilateHFLATBUFFERS_FINAL_CLASS3428 bool mutate_dilateH(int32_t _dilateH) {
3429 return SetField<int32_t>(VT_DILATEH, _dilateH, 0);
3430 }
hasBiasFLATBUFFERS_FINAL_CLASS3431 bool hasBias() const {
3432 return GetField<uint8_t>(VT_HASBIAS, 0) != 0;
3433 }
mutate_hasBiasFLATBUFFERS_FINAL_CLASS3434 bool mutate_hasBias(bool _hasBias) {
3435 return SetField<uint8_t>(VT_HASBIAS, static_cast<uint8_t>(_hasBias), 0);
3436 }
input_shapeFLATBUFFERS_FINAL_CLASS3437 const flatbuffers::Vector<int32_t> *input_shape() const {
3438 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INPUT_SHAPE);
3439 }
mutable_input_shapeFLATBUFFERS_FINAL_CLASS3440 flatbuffers::Vector<int32_t> *mutable_input_shape() {
3441 return GetPointer<flatbuffers::Vector<int32_t> *>(VT_INPUT_SHAPE);
3442 }
activationTypeFLATBUFFERS_FINAL_CLASS3443 mindspore::schema::v0::ActivationType activationType() const {
3444 return static_cast<mindspore::schema::v0::ActivationType>(GetField<int8_t>(VT_ACTIVATIONTYPE, 0));
3445 }
mutate_activationTypeFLATBUFFERS_FINAL_CLASS3446 bool mutate_activationType(mindspore::schema::v0::ActivationType _activationType) {
3447 return SetField<int8_t>(VT_ACTIVATIONTYPE, static_cast<int8_t>(_activationType), 0);
3448 }
VerifyFLATBUFFERS_FINAL_CLASS3449 bool Verify(flatbuffers::Verifier &verifier) const {
3450 return VerifyTableStart(verifier) &&
3451 VerifyField<int32_t>(verifier, VT_FORMAT) &&
3452 VerifyField<int32_t>(verifier, VT_GROUP) &&
3453 VerifyField<int32_t>(verifier, VT_CHANNELIN) &&
3454 VerifyField<int32_t>(verifier, VT_CHANNELOUT) &&
3455 VerifyField<int32_t>(verifier, VT_KERNELW) &&
3456 VerifyField<int32_t>(verifier, VT_KERNELH) &&
3457 VerifyField<int32_t>(verifier, VT_STRIDEW) &&
3458 VerifyField<int32_t>(verifier, VT_STRIDEH) &&
3459 VerifyField<int8_t>(verifier, VT_PADMODE) &&
3460 VerifyField<int32_t>(verifier, VT_PADUP) &&
3461 VerifyField<int32_t>(verifier, VT_PADDOWN) &&
3462 VerifyField<int32_t>(verifier, VT_PADLEFT) &&
3463 VerifyField<int32_t>(verifier, VT_PADRIGHT) &&
3464 VerifyField<int32_t>(verifier, VT_DILATEW) &&
3465 VerifyField<int32_t>(verifier, VT_DILATEH) &&
3466 VerifyField<uint8_t>(verifier, VT_HASBIAS) &&
3467 VerifyOffset(verifier, VT_INPUT_SHAPE) &&
3468 verifier.VerifyVector(input_shape()) &&
3469 VerifyField<int8_t>(verifier, VT_ACTIVATIONTYPE) &&
3470 verifier.EndTable();
3471 }
3472 Conv2DGradInputT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3473 void UnPackTo(Conv2DGradInputT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3474 static flatbuffers::Offset<Conv2DGradInput> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DGradInputT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3475 };
3476
3477 struct Conv2DGradInputBuilder {
3478 typedef Conv2DGradInput Table;
3479 flatbuffers::FlatBufferBuilder &fbb_;
3480 flatbuffers::uoffset_t start_;
add_formatConv2DGradInputBuilder3481 void add_format(mindspore::schema::v0::Format format) {
3482 fbb_.AddElement<int32_t>(Conv2DGradInput::VT_FORMAT, static_cast<int32_t>(format), 0);
3483 }
add_groupConv2DGradInputBuilder3484 void add_group(int32_t group) {
3485 fbb_.AddElement<int32_t>(Conv2DGradInput::VT_GROUP, group, 0);
3486 }
add_channelInConv2DGradInputBuilder3487 void add_channelIn(int32_t channelIn) {
3488 fbb_.AddElement<int32_t>(Conv2DGradInput::VT_CHANNELIN, channelIn, 0);
3489 }
add_channelOutConv2DGradInputBuilder3490 void add_channelOut(int32_t channelOut) {
3491 fbb_.AddElement<int32_t>(Conv2DGradInput::VT_CHANNELOUT, channelOut, 0);
3492 }
add_kernelWConv2DGradInputBuilder3493