1 // automatically generated by the FlatBuffers compiler, do not modify
2
3
4 #ifndef FLATBUFFERS_GENERATED_TFQUANTIZEOP_MNN_H_
5 #define FLATBUFFERS_GENERATED_TFQUANTIZEOP_MNN_H_
6
7
8 #include "CaffeOp_generated.h"
9 #include "Tensor_generated.h"
10 #include "Type_generated.h"
11
12 namespace MNN {
13
14 struct QuantizedParam;
15 struct QuantizedParamT;
16
17 struct QuantizedAdd;
18 struct QuantizedAddT;
19
20 struct Dequantize;
21 struct DequantizeT;
22
23 struct QuantizedAvgPool;
24 struct QuantizedAvgPoolT;
25
26 struct QuantizedBiasAdd;
27 struct QuantizedBiasAddT;
28
29 struct QuantizedConcat;
30 struct QuantizedConcatT;
31
32 struct QuantizedLogistic;
33 struct QuantizedLogisticT;
34
35 struct QuantizedMatMul;
36 struct QuantizedMatMulT;
37
38 struct QuantizedMaxPool;
39 struct QuantizedMaxPoolT;
40
41 struct QuantizedRelu;
42 struct QuantizedReluT;
43
44 struct QuantizedRelu6;
45 struct QuantizedRelu6T;
46
47 struct QuantizedReshape;
48 struct QuantizedReshapeT;
49
50 struct QuantizedSoftmax;
51 struct QuantizedSoftmaxT;
52
53 struct QuantizeV2;
54 struct QuantizeV2T;
55
56 struct RequantizationRange;
57 struct RequantizationRangeT;
58
59 struct Requantize;
60 struct RequantizeT;
61
62 struct TfQuantizedConv2D;
63 struct TfQuantizedConv2DT;
64
65 inline const flatbuffers::TypeTable *QuantizedParamTypeTable();
66
67 inline const flatbuffers::TypeTable *QuantizedAddTypeTable();
68
69 inline const flatbuffers::TypeTable *DequantizeTypeTable();
70
71 inline const flatbuffers::TypeTable *QuantizedAvgPoolTypeTable();
72
73 inline const flatbuffers::TypeTable *QuantizedBiasAddTypeTable();
74
75 inline const flatbuffers::TypeTable *QuantizedConcatTypeTable();
76
77 inline const flatbuffers::TypeTable *QuantizedLogisticTypeTable();
78
79 inline const flatbuffers::TypeTable *QuantizedMatMulTypeTable();
80
81 inline const flatbuffers::TypeTable *QuantizedMaxPoolTypeTable();
82
83 inline const flatbuffers::TypeTable *QuantizedReluTypeTable();
84
85 inline const flatbuffers::TypeTable *QuantizedRelu6TypeTable();
86
87 inline const flatbuffers::TypeTable *QuantizedReshapeTypeTable();
88
89 inline const flatbuffers::TypeTable *QuantizedSoftmaxTypeTable();
90
91 inline const flatbuffers::TypeTable *QuantizeV2TypeTable();
92
93 inline const flatbuffers::TypeTable *RequantizationRangeTypeTable();
94
95 inline const flatbuffers::TypeTable *RequantizeTypeTable();
96
97 inline const flatbuffers::TypeTable *TfQuantizedConv2DTypeTable();
98
99 enum FusedActivation {
100 FusedActivation_kTfLiteActNone = 0,
101 FusedActivation_kTfLiteActRelu = 1,
102 FusedActivation_kTfLiteActRelu1 = 2,
103 FusedActivation_kTfLiteActRelu6 = 3,
104 FusedActivation_kTfLiteActTanh = 4,
105 FusedActivation_kTfLiteActSignBit = 5,
106 FusedActivation_kTfLiteActSigmoid = 6,
107 FusedActivation_MIN = FusedActivation_kTfLiteActNone,
108 FusedActivation_MAX = FusedActivation_kTfLiteActSigmoid
109 };
110
EnumValuesFusedActivation()111 inline const FusedActivation (&EnumValuesFusedActivation())[7] {
112 static const FusedActivation values[] = {
113 FusedActivation_kTfLiteActNone,
114 FusedActivation_kTfLiteActRelu,
115 FusedActivation_kTfLiteActRelu1,
116 FusedActivation_kTfLiteActRelu6,
117 FusedActivation_kTfLiteActTanh,
118 FusedActivation_kTfLiteActSignBit,
119 FusedActivation_kTfLiteActSigmoid
120 };
121 return values;
122 }
123
EnumNamesFusedActivation()124 inline const char * const *EnumNamesFusedActivation() {
125 static const char * const names[] = {
126 "kTfLiteActNone",
127 "kTfLiteActRelu",
128 "kTfLiteActRelu1",
129 "kTfLiteActRelu6",
130 "kTfLiteActTanh",
131 "kTfLiteActSignBit",
132 "kTfLiteActSigmoid",
133 nullptr
134 };
135 return names;
136 }
137
EnumNameFusedActivation(FusedActivation e)138 inline const char *EnumNameFusedActivation(FusedActivation e) {
139 if (e < FusedActivation_kTfLiteActNone || e > FusedActivation_kTfLiteActSigmoid) return "";
140 const size_t index = static_cast<int>(e);
141 return EnumNamesFusedActivation()[index];
142 }
143
144 enum ModeFormat {
145 ModeFormat_TENSORFLOW = 0,
146 ModeFormat_TFLITE = 1,
147 ModeFormat_MIN = ModeFormat_TENSORFLOW,
148 ModeFormat_MAX = ModeFormat_TFLITE
149 };
150
EnumValuesModeFormat()151 inline const ModeFormat (&EnumValuesModeFormat())[2] {
152 static const ModeFormat values[] = {
153 ModeFormat_TENSORFLOW,
154 ModeFormat_TFLITE
155 };
156 return values;
157 }
158
EnumNamesModeFormat()159 inline const char * const *EnumNamesModeFormat() {
160 static const char * const names[] = {
161 "TENSORFLOW",
162 "TFLITE",
163 nullptr
164 };
165 return names;
166 }
167
EnumNameModeFormat(ModeFormat e)168 inline const char *EnumNameModeFormat(ModeFormat e) {
169 if (e < ModeFormat_TENSORFLOW || e > ModeFormat_TFLITE) return "";
170 const size_t index = static_cast<int>(e);
171 return EnumNamesModeFormat()[index];
172 }
173
174 enum QuantizeMode {
175 QuantizeMode_MIN_COMBINED = 0,
176 QuantizeMode_MIN_FIRST = 1,
177 QuantizeMode_SCALED = 2,
178 QuantizeMode_MIN = QuantizeMode_MIN_COMBINED,
179 QuantizeMode_MAX = QuantizeMode_SCALED
180 };
181
EnumValuesQuantizeMode()182 inline const QuantizeMode (&EnumValuesQuantizeMode())[3] {
183 static const QuantizeMode values[] = {
184 QuantizeMode_MIN_COMBINED,
185 QuantizeMode_MIN_FIRST,
186 QuantizeMode_SCALED
187 };
188 return values;
189 }
190
EnumNamesQuantizeMode()191 inline const char * const *EnumNamesQuantizeMode() {
192 static const char * const names[] = {
193 "MIN_COMBINED",
194 "MIN_FIRST",
195 "SCALED",
196 nullptr
197 };
198 return names;
199 }
200
EnumNameQuantizeMode(QuantizeMode e)201 inline const char *EnumNameQuantizeMode(QuantizeMode e) {
202 if (e < QuantizeMode_MIN_COMBINED || e > QuantizeMode_SCALED) return "";
203 const size_t index = static_cast<int>(e);
204 return EnumNamesQuantizeMode()[index];
205 }
206
207 enum QuantizeRoundMode {
208 QuantizeRoundMode_HALF_AWAY_FROM_ZERO = 0,
209 QuantizeRoundMode_HALF_TO_EVEN = 1,
210 QuantizeRoundMode_MIN = QuantizeRoundMode_HALF_AWAY_FROM_ZERO,
211 QuantizeRoundMode_MAX = QuantizeRoundMode_HALF_TO_EVEN
212 };
213
EnumValuesQuantizeRoundMode()214 inline const QuantizeRoundMode (&EnumValuesQuantizeRoundMode())[2] {
215 static const QuantizeRoundMode values[] = {
216 QuantizeRoundMode_HALF_AWAY_FROM_ZERO,
217 QuantizeRoundMode_HALF_TO_EVEN
218 };
219 return values;
220 }
221
EnumNamesQuantizeRoundMode()222 inline const char * const *EnumNamesQuantizeRoundMode() {
223 static const char * const names[] = {
224 "HALF_AWAY_FROM_ZERO",
225 "HALF_TO_EVEN",
226 nullptr
227 };
228 return names;
229 }
230
EnumNameQuantizeRoundMode(QuantizeRoundMode e)231 inline const char *EnumNameQuantizeRoundMode(QuantizeRoundMode e) {
232 if (e < QuantizeRoundMode_HALF_AWAY_FROM_ZERO || e > QuantizeRoundMode_HALF_TO_EVEN) return "";
233 const size_t index = static_cast<int>(e);
234 return EnumNamesQuantizeRoundMode()[index];
235 }
236
237 struct QuantizedParamT : public flatbuffers::NativeTable {
238 typedef QuantizedParam TableType;
239 int32_t zeroPoint;
240 float scale;
QuantizedParamTQuantizedParamT241 QuantizedParamT()
242 : zeroPoint(0),
243 scale(0.0f) {
244 }
245 };
246
247 struct QuantizedParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
248 typedef QuantizedParamT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS249 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
250 return QuantizedParamTypeTable();
251 }
zeroPointFLATBUFFERS_FINAL_CLASS252 int32_t zeroPoint() const {
253 return GetField<int32_t>(4, 0);
254 }
scaleFLATBUFFERS_FINAL_CLASS255 float scale() const {
256 return GetField<float>(6, 0.0f);
257 }
VerifyFLATBUFFERS_FINAL_CLASS258 bool Verify(flatbuffers::Verifier &verifier) const {
259 return VerifyTableStart(verifier) &&
260 VerifyField<int32_t>(verifier, 4) &&
261 VerifyField<float>(verifier, 6) &&
262 verifier.EndTable();
263 }
264 QuantizedParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
265 void UnPackTo(QuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
266 static flatbuffers::Offset<QuantizedParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
267 };
268
269 struct QuantizedParamBuilder {
270 flatbuffers::FlatBufferBuilder &fbb_;
271 flatbuffers::uoffset_t start_;
add_zeroPointQuantizedParamBuilder272 void add_zeroPoint(int32_t zeroPoint) {
273 fbb_.AddElement<int32_t>(4, zeroPoint, 0);
274 }
add_scaleQuantizedParamBuilder275 void add_scale(float scale) {
276 fbb_.AddElement<float>(6, scale, 0.0f);
277 }
QuantizedParamBuilderQuantizedParamBuilder278 explicit QuantizedParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
279 : fbb_(_fbb) {
280 start_ = fbb_.StartTable();
281 }
282 QuantizedParamBuilder &operator=(const QuantizedParamBuilder &);
FinishQuantizedParamBuilder283 flatbuffers::Offset<QuantizedParam> Finish() {
284 const auto end = fbb_.EndTable(start_);
285 auto o = flatbuffers::Offset<QuantizedParam>(end);
286 return o;
287 }
288 };
289
290 inline flatbuffers::Offset<QuantizedParam> CreateQuantizedParam(
291 flatbuffers::FlatBufferBuilder &_fbb,
292 int32_t zeroPoint = 0,
293 float scale = 0.0f) {
294 QuantizedParamBuilder builder_(_fbb);
295 builder_.add_scale(scale);
296 builder_.add_zeroPoint(zeroPoint);
297 return builder_.Finish();
298 }
299
300 flatbuffers::Offset<QuantizedParam> CreateQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
301
302 struct QuantizedAddT : public flatbuffers::NativeTable {
303 typedef QuantizedAdd TableType;
304 FusedActivation activationType;
305 std::unique_ptr<QuantizedParamT> input1QuantizedParam;
306 std::unique_ptr<QuantizedParamT> input2QuantizedParam;
307 std::unique_ptr<QuantizedParamT> outputQuantizedParam;
QuantizedAddTQuantizedAddT308 QuantizedAddT()
309 : activationType(FusedActivation_kTfLiteActNone) {
310 }
311 };
312
313 struct QuantizedAdd FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
314 typedef QuantizedAddT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS315 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
316 return QuantizedAddTypeTable();
317 }
activationTypeFLATBUFFERS_FINAL_CLASS318 FusedActivation activationType() const {
319 return static_cast<FusedActivation>(GetField<int8_t>(4, 0));
320 }
input1QuantizedParamFLATBUFFERS_FINAL_CLASS321 const QuantizedParam *input1QuantizedParam() const {
322 return GetPointer<const QuantizedParam *>(6);
323 }
input2QuantizedParamFLATBUFFERS_FINAL_CLASS324 const QuantizedParam *input2QuantizedParam() const {
325 return GetPointer<const QuantizedParam *>(8);
326 }
outputQuantizedParamFLATBUFFERS_FINAL_CLASS327 const QuantizedParam *outputQuantizedParam() const {
328 return GetPointer<const QuantizedParam *>(10);
329 }
VerifyFLATBUFFERS_FINAL_CLASS330 bool Verify(flatbuffers::Verifier &verifier) const {
331 return VerifyTableStart(verifier) &&
332 VerifyField<int8_t>(verifier, 4) &&
333 VerifyOffset(verifier, 6) &&
334 verifier.VerifyTable(input1QuantizedParam()) &&
335 VerifyOffset(verifier, 8) &&
336 verifier.VerifyTable(input2QuantizedParam()) &&
337 VerifyOffset(verifier, 10) &&
338 verifier.VerifyTable(outputQuantizedParam()) &&
339 verifier.EndTable();
340 }
341 QuantizedAddT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
342 void UnPackTo(QuantizedAddT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
343 static flatbuffers::Offset<QuantizedAdd> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedAddT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
344 };
345
346 struct QuantizedAddBuilder {
347 flatbuffers::FlatBufferBuilder &fbb_;
348 flatbuffers::uoffset_t start_;
add_activationTypeQuantizedAddBuilder349 void add_activationType(FusedActivation activationType) {
350 fbb_.AddElement<int8_t>(4, static_cast<int8_t>(activationType), 0);
351 }
add_input1QuantizedParamQuantizedAddBuilder352 void add_input1QuantizedParam(flatbuffers::Offset<QuantizedParam> input1QuantizedParam) {
353 fbb_.AddOffset(6, input1QuantizedParam);
354 }
add_input2QuantizedParamQuantizedAddBuilder355 void add_input2QuantizedParam(flatbuffers::Offset<QuantizedParam> input2QuantizedParam) {
356 fbb_.AddOffset(8, input2QuantizedParam);
357 }
add_outputQuantizedParamQuantizedAddBuilder358 void add_outputQuantizedParam(flatbuffers::Offset<QuantizedParam> outputQuantizedParam) {
359 fbb_.AddOffset(10, outputQuantizedParam);
360 }
QuantizedAddBuilderQuantizedAddBuilder361 explicit QuantizedAddBuilder(flatbuffers::FlatBufferBuilder &_fbb)
362 : fbb_(_fbb) {
363 start_ = fbb_.StartTable();
364 }
365 QuantizedAddBuilder &operator=(const QuantizedAddBuilder &);
FinishQuantizedAddBuilder366 flatbuffers::Offset<QuantizedAdd> Finish() {
367 const auto end = fbb_.EndTable(start_);
368 auto o = flatbuffers::Offset<QuantizedAdd>(end);
369 return o;
370 }
371 };
372
373 inline flatbuffers::Offset<QuantizedAdd> CreateQuantizedAdd(
374 flatbuffers::FlatBufferBuilder &_fbb,
375 FusedActivation activationType = FusedActivation_kTfLiteActNone,
376 flatbuffers::Offset<QuantizedParam> input1QuantizedParam = 0,
377 flatbuffers::Offset<QuantizedParam> input2QuantizedParam = 0,
378 flatbuffers::Offset<QuantizedParam> outputQuantizedParam = 0) {
379 QuantizedAddBuilder builder_(_fbb);
380 builder_.add_outputQuantizedParam(outputQuantizedParam);
381 builder_.add_input2QuantizedParam(input2QuantizedParam);
382 builder_.add_input1QuantizedParam(input1QuantizedParam);
383 builder_.add_activationType(activationType);
384 return builder_.Finish();
385 }
386
387 flatbuffers::Offset<QuantizedAdd> CreateQuantizedAdd(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedAddT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
388
389 struct DequantizeT : public flatbuffers::NativeTable {
390 typedef Dequantize TableType;
391 std::unique_ptr<QuantizedParamT> inputQuantizedParam;
392 QuantizeMode mode;
393 ModeFormat modelFormat;
394 DataType type;
DequantizeTDequantizeT395 DequantizeT()
396 : mode(QuantizeMode_MIN_COMBINED),
397 modelFormat(ModeFormat_TENSORFLOW),
398 type(DataType_DT_INVALID) {
399 }
400 };
401
402 struct Dequantize FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
403 typedef DequantizeT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS404 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
405 return DequantizeTypeTable();
406 }
inputQuantizedParamFLATBUFFERS_FINAL_CLASS407 const QuantizedParam *inputQuantizedParam() const {
408 return GetPointer<const QuantizedParam *>(4);
409 }
modeFLATBUFFERS_FINAL_CLASS410 QuantizeMode mode() const {
411 return static_cast<QuantizeMode>(GetField<int8_t>(6, 0));
412 }
modelFormatFLATBUFFERS_FINAL_CLASS413 ModeFormat modelFormat() const {
414 return static_cast<ModeFormat>(GetField<int8_t>(8, 0));
415 }
typeFLATBUFFERS_FINAL_CLASS416 DataType type() const {
417 return static_cast<DataType>(GetField<int32_t>(10, 0));
418 }
VerifyFLATBUFFERS_FINAL_CLASS419 bool Verify(flatbuffers::Verifier &verifier) const {
420 return VerifyTableStart(verifier) &&
421 VerifyOffset(verifier, 4) &&
422 verifier.VerifyTable(inputQuantizedParam()) &&
423 VerifyField<int8_t>(verifier, 6) &&
424 VerifyField<int8_t>(verifier, 8) &&
425 VerifyField<int32_t>(verifier, 10) &&
426 verifier.EndTable();
427 }
428 DequantizeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
429 void UnPackTo(DequantizeT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
430 static flatbuffers::Offset<Dequantize> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
431 };
432
433 struct DequantizeBuilder {
434 flatbuffers::FlatBufferBuilder &fbb_;
435 flatbuffers::uoffset_t start_;
add_inputQuantizedParamDequantizeBuilder436 void add_inputQuantizedParam(flatbuffers::Offset<QuantizedParam> inputQuantizedParam) {
437 fbb_.AddOffset(4, inputQuantizedParam);
438 }
add_modeDequantizeBuilder439 void add_mode(QuantizeMode mode) {
440 fbb_.AddElement<int8_t>(6, static_cast<int8_t>(mode), 0);
441 }
add_modelFormatDequantizeBuilder442 void add_modelFormat(ModeFormat modelFormat) {
443 fbb_.AddElement<int8_t>(8, static_cast<int8_t>(modelFormat), 0);
444 }
add_typeDequantizeBuilder445 void add_type(DataType type) {
446 fbb_.AddElement<int32_t>(10, static_cast<int32_t>(type), 0);
447 }
DequantizeBuilderDequantizeBuilder448 explicit DequantizeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
449 : fbb_(_fbb) {
450 start_ = fbb_.StartTable();
451 }
452 DequantizeBuilder &operator=(const DequantizeBuilder &);
FinishDequantizeBuilder453 flatbuffers::Offset<Dequantize> Finish() {
454 const auto end = fbb_.EndTable(start_);
455 auto o = flatbuffers::Offset<Dequantize>(end);
456 return o;
457 }
458 };
459
460 inline flatbuffers::Offset<Dequantize> CreateDequantize(
461 flatbuffers::FlatBufferBuilder &_fbb,
462 flatbuffers::Offset<QuantizedParam> inputQuantizedParam = 0,
463 QuantizeMode mode = QuantizeMode_MIN_COMBINED,
464 ModeFormat modelFormat = ModeFormat_TENSORFLOW,
465 DataType type = DataType_DT_INVALID) {
466 DequantizeBuilder builder_(_fbb);
467 builder_.add_type(type);
468 builder_.add_inputQuantizedParam(inputQuantizedParam);
469 builder_.add_modelFormat(modelFormat);
470 builder_.add_mode(mode);
471 return builder_.Finish();
472 }
473
474 flatbuffers::Offset<Dequantize> CreateDequantize(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
475
476 struct QuantizedAvgPoolT : public flatbuffers::NativeTable {
477 typedef QuantizedAvgPool TableType;
478 int32_t kernelX;
479 int32_t kernelY;
480 ModeFormat modelFormat;
481 int32_t outputActivationMax;
482 int32_t outputActivationMin;
483 PoolPadType padType;
484 int32_t padX;
485 int32_t padY;
486 int32_t strideX;
487 int32_t strideY;
488 DataType type;
QuantizedAvgPoolTQuantizedAvgPoolT489 QuantizedAvgPoolT()
490 : kernelX(0),
491 kernelY(0),
492 modelFormat(ModeFormat_TENSORFLOW),
493 outputActivationMax(0),
494 outputActivationMin(0),
495 padType(PoolPadType_CAFFE),
496 padX(0),
497 padY(0),
498 strideX(0),
499 strideY(0),
500 type(DataType_DT_INVALID) {
501 }
502 };
503
504 struct QuantizedAvgPool FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
505 typedef QuantizedAvgPoolT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS506 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
507 return QuantizedAvgPoolTypeTable();
508 }
kernelXFLATBUFFERS_FINAL_CLASS509 int32_t kernelX() const {
510 return GetField<int32_t>(4, 0);
511 }
kernelYFLATBUFFERS_FINAL_CLASS512 int32_t kernelY() const {
513 return GetField<int32_t>(6, 0);
514 }
modelFormatFLATBUFFERS_FINAL_CLASS515 ModeFormat modelFormat() const {
516 return static_cast<ModeFormat>(GetField<int8_t>(8, 0));
517 }
outputActivationMaxFLATBUFFERS_FINAL_CLASS518 int32_t outputActivationMax() const {
519 return GetField<int32_t>(10, 0);
520 }
outputActivationMinFLATBUFFERS_FINAL_CLASS521 int32_t outputActivationMin() const {
522 return GetField<int32_t>(12, 0);
523 }
padTypeFLATBUFFERS_FINAL_CLASS524 PoolPadType padType() const {
525 return static_cast<PoolPadType>(GetField<int8_t>(14, 0));
526 }
padXFLATBUFFERS_FINAL_CLASS527 int32_t padX() const {
528 return GetField<int32_t>(16, 0);
529 }
padYFLATBUFFERS_FINAL_CLASS530 int32_t padY() const {
531 return GetField<int32_t>(18, 0);
532 }
strideXFLATBUFFERS_FINAL_CLASS533 int32_t strideX() const {
534 return GetField<int32_t>(20, 0);
535 }
strideYFLATBUFFERS_FINAL_CLASS536 int32_t strideY() const {
537 return GetField<int32_t>(22, 0);
538 }
typeFLATBUFFERS_FINAL_CLASS539 DataType type() const {
540 return static_cast<DataType>(GetField<int32_t>(24, 0));
541 }
VerifyFLATBUFFERS_FINAL_CLASS542 bool Verify(flatbuffers::Verifier &verifier) const {
543 return VerifyTableStart(verifier) &&
544 VerifyField<int32_t>(verifier, 4) &&
545 VerifyField<int32_t>(verifier, 6) &&
546 VerifyField<int8_t>(verifier, 8) &&
547 VerifyField<int32_t>(verifier, 10) &&
548 VerifyField<int32_t>(verifier, 12) &&
549 VerifyField<int8_t>(verifier, 14) &&
550 VerifyField<int32_t>(verifier, 16) &&
551 VerifyField<int32_t>(verifier, 18) &&
552 VerifyField<int32_t>(verifier, 20) &&
553 VerifyField<int32_t>(verifier, 22) &&
554 VerifyField<int32_t>(verifier, 24) &&
555 verifier.EndTable();
556 }
557 QuantizedAvgPoolT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
558 void UnPackTo(QuantizedAvgPoolT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
559 static flatbuffers::Offset<QuantizedAvgPool> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedAvgPoolT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
560 };
561
562 struct QuantizedAvgPoolBuilder {
563 flatbuffers::FlatBufferBuilder &fbb_;
564 flatbuffers::uoffset_t start_;
add_kernelXQuantizedAvgPoolBuilder565 void add_kernelX(int32_t kernelX) {
566 fbb_.AddElement<int32_t>(4, kernelX, 0);
567 }
add_kernelYQuantizedAvgPoolBuilder568 void add_kernelY(int32_t kernelY) {
569 fbb_.AddElement<int32_t>(6, kernelY, 0);
570 }
add_modelFormatQuantizedAvgPoolBuilder571 void add_modelFormat(ModeFormat modelFormat) {
572 fbb_.AddElement<int8_t>(8, static_cast<int8_t>(modelFormat), 0);
573 }
add_outputActivationMaxQuantizedAvgPoolBuilder574 void add_outputActivationMax(int32_t outputActivationMax) {
575 fbb_.AddElement<int32_t>(10, outputActivationMax, 0);
576 }
add_outputActivationMinQuantizedAvgPoolBuilder577 void add_outputActivationMin(int32_t outputActivationMin) {
578 fbb_.AddElement<int32_t>(12, outputActivationMin, 0);
579 }
add_padTypeQuantizedAvgPoolBuilder580 void add_padType(PoolPadType padType) {
581 fbb_.AddElement<int8_t>(14, static_cast<int8_t>(padType), 0);
582 }
add_padXQuantizedAvgPoolBuilder583 void add_padX(int32_t padX) {
584 fbb_.AddElement<int32_t>(16, padX, 0);
585 }
add_padYQuantizedAvgPoolBuilder586 void add_padY(int32_t padY) {
587 fbb_.AddElement<int32_t>(18, padY, 0);
588 }
add_strideXQuantizedAvgPoolBuilder589 void add_strideX(int32_t strideX) {
590 fbb_.AddElement<int32_t>(20, strideX, 0);
591 }
add_strideYQuantizedAvgPoolBuilder592 void add_strideY(int32_t strideY) {
593 fbb_.AddElement<int32_t>(22, strideY, 0);
594 }
add_typeQuantizedAvgPoolBuilder595 void add_type(DataType type) {
596 fbb_.AddElement<int32_t>(24, static_cast<int32_t>(type), 0);
597 }
QuantizedAvgPoolBuilderQuantizedAvgPoolBuilder598 explicit QuantizedAvgPoolBuilder(flatbuffers::FlatBufferBuilder &_fbb)
599 : fbb_(_fbb) {
600 start_ = fbb_.StartTable();
601 }
602 QuantizedAvgPoolBuilder &operator=(const QuantizedAvgPoolBuilder &);
FinishQuantizedAvgPoolBuilder603 flatbuffers::Offset<QuantizedAvgPool> Finish() {
604 const auto end = fbb_.EndTable(start_);
605 auto o = flatbuffers::Offset<QuantizedAvgPool>(end);
606 return o;
607 }
608 };
609
610 inline flatbuffers::Offset<QuantizedAvgPool> CreateQuantizedAvgPool(
611 flatbuffers::FlatBufferBuilder &_fbb,
612 int32_t kernelX = 0,
613 int32_t kernelY = 0,
614 ModeFormat modelFormat = ModeFormat_TENSORFLOW,
615 int32_t outputActivationMax = 0,
616 int32_t outputActivationMin = 0,
617 PoolPadType padType = PoolPadType_CAFFE,
618 int32_t padX = 0,
619 int32_t padY = 0,
620 int32_t strideX = 0,
621 int32_t strideY = 0,
622 DataType type = DataType_DT_INVALID) {
623 QuantizedAvgPoolBuilder builder_(_fbb);
624 builder_.add_type(type);
625 builder_.add_strideY(strideY);
626 builder_.add_strideX(strideX);
627 builder_.add_padY(padY);
628 builder_.add_padX(padX);
629 builder_.add_outputActivationMin(outputActivationMin);
630 builder_.add_outputActivationMax(outputActivationMax);
631 builder_.add_kernelY(kernelY);
632 builder_.add_kernelX(kernelX);
633 builder_.add_padType(padType);
634 builder_.add_modelFormat(modelFormat);
635 return builder_.Finish();
636 }
637
638 flatbuffers::Offset<QuantizedAvgPool> CreateQuantizedAvgPool(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedAvgPoolT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
639
640 struct QuantizedBiasAddT : public flatbuffers::NativeTable {
641 typedef QuantizedBiasAdd TableType;
642 std::vector<int32_t> bias;
643 DataType inputType;
644 int32_t max;
645 int32_t min;
646 DataType outputType;
QuantizedBiasAddTQuantizedBiasAddT647 QuantizedBiasAddT()
648 : inputType(DataType_DT_INVALID),
649 max(0),
650 min(0),
651 outputType(DataType_DT_INVALID) {
652 }
653 };
654
655 struct QuantizedBiasAdd FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
656 typedef QuantizedBiasAddT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS657 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
658 return QuantizedBiasAddTypeTable();
659 }
biasFLATBUFFERS_FINAL_CLASS660 const flatbuffers::Vector<int32_t> *bias() const {
661 return GetPointer<const flatbuffers::Vector<int32_t> *>(4);
662 }
inputTypeFLATBUFFERS_FINAL_CLASS663 DataType inputType() const {
664 return static_cast<DataType>(GetField<int32_t>(6, 0));
665 }
maxFLATBUFFERS_FINAL_CLASS666 int32_t max() const {
667 return GetField<int32_t>(8, 0);
668 }
minFLATBUFFERS_FINAL_CLASS669 int32_t min() const {
670 return GetField<int32_t>(10, 0);
671 }
outputTypeFLATBUFFERS_FINAL_CLASS672 DataType outputType() const {
673 return static_cast<DataType>(GetField<int32_t>(12, 0));
674 }
VerifyFLATBUFFERS_FINAL_CLASS675 bool Verify(flatbuffers::Verifier &verifier) const {
676 return VerifyTableStart(verifier) &&
677 VerifyOffset(verifier, 4) &&
678 verifier.VerifyVector(bias()) &&
679 VerifyField<int32_t>(verifier, 6) &&
680 VerifyField<int32_t>(verifier, 8) &&
681 VerifyField<int32_t>(verifier, 10) &&
682 VerifyField<int32_t>(verifier, 12) &&
683 verifier.EndTable();
684 }
685 QuantizedBiasAddT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
686 void UnPackTo(QuantizedBiasAddT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
687 static flatbuffers::Offset<QuantizedBiasAdd> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedBiasAddT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
688 };
689
690 struct QuantizedBiasAddBuilder {
691 flatbuffers::FlatBufferBuilder &fbb_;
692 flatbuffers::uoffset_t start_;
add_biasQuantizedBiasAddBuilder693 void add_bias(flatbuffers::Offset<flatbuffers::Vector<int32_t>> bias) {
694 fbb_.AddOffset(4, bias);
695 }
add_inputTypeQuantizedBiasAddBuilder696 void add_inputType(DataType inputType) {
697 fbb_.AddElement<int32_t>(6, static_cast<int32_t>(inputType), 0);
698 }
add_maxQuantizedBiasAddBuilder699 void add_max(int32_t max) {
700 fbb_.AddElement<int32_t>(8, max, 0);
701 }
add_minQuantizedBiasAddBuilder702 void add_min(int32_t min) {
703 fbb_.AddElement<int32_t>(10, min, 0);
704 }
add_outputTypeQuantizedBiasAddBuilder705 void add_outputType(DataType outputType) {
706 fbb_.AddElement<int32_t>(12, static_cast<int32_t>(outputType), 0);
707 }
QuantizedBiasAddBuilderQuantizedBiasAddBuilder708 explicit QuantizedBiasAddBuilder(flatbuffers::FlatBufferBuilder &_fbb)
709 : fbb_(_fbb) {
710 start_ = fbb_.StartTable();
711 }
712 QuantizedBiasAddBuilder &operator=(const QuantizedBiasAddBuilder &);
FinishQuantizedBiasAddBuilder713 flatbuffers::Offset<QuantizedBiasAdd> Finish() {
714 const auto end = fbb_.EndTable(start_);
715 auto o = flatbuffers::Offset<QuantizedBiasAdd>(end);
716 return o;
717 }
718 };
719
720 inline flatbuffers::Offset<QuantizedBiasAdd> CreateQuantizedBiasAdd(
721 flatbuffers::FlatBufferBuilder &_fbb,
722 flatbuffers::Offset<flatbuffers::Vector<int32_t>> bias = 0,
723 DataType inputType = DataType_DT_INVALID,
724 int32_t max = 0,
725 int32_t min = 0,
726 DataType outputType = DataType_DT_INVALID) {
727 QuantizedBiasAddBuilder builder_(_fbb);
728 builder_.add_outputType(outputType);
729 builder_.add_min(min);
730 builder_.add_max(max);
731 builder_.add_inputType(inputType);
732 builder_.add_bias(bias);
733 return builder_.Finish();
734 }
735
736 flatbuffers::Offset<QuantizedBiasAdd> CreateQuantizedBiasAdd(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedBiasAddT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
737
738 struct QuantizedConcatT : public flatbuffers::NativeTable {
739 typedef QuantizedConcat TableType;
740 FusedActivation activationType;
741 int32_t axis;
742 std::vector<float> inputScale;
743 std::vector<int32_t> inputZeroPoint;
744 std::unique_ptr<QuantizedParamT> outputQuantizedParam;
QuantizedConcatTQuantizedConcatT745 QuantizedConcatT()
746 : activationType(FusedActivation_kTfLiteActNone),
747 axis(0) {
748 }
749 };
750
751 struct QuantizedConcat FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
752 typedef QuantizedConcatT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS753 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
754 return QuantizedConcatTypeTable();
755 }
activationTypeFLATBUFFERS_FINAL_CLASS756 FusedActivation activationType() const {
757 return static_cast<FusedActivation>(GetField<int8_t>(4, 0));
758 }
axisFLATBUFFERS_FINAL_CLASS759 int32_t axis() const {
760 return GetField<int32_t>(6, 0);
761 }
inputScaleFLATBUFFERS_FINAL_CLASS762 const flatbuffers::Vector<float> *inputScale() const {
763 return GetPointer<const flatbuffers::Vector<float> *>(8);
764 }
inputZeroPointFLATBUFFERS_FINAL_CLASS765 const flatbuffers::Vector<int32_t> *inputZeroPoint() const {
766 return GetPointer<const flatbuffers::Vector<int32_t> *>(10);
767 }
outputQuantizedParamFLATBUFFERS_FINAL_CLASS768 const QuantizedParam *outputQuantizedParam() const {
769 return GetPointer<const QuantizedParam *>(12);
770 }
VerifyFLATBUFFERS_FINAL_CLASS771 bool Verify(flatbuffers::Verifier &verifier) const {
772 return VerifyTableStart(verifier) &&
773 VerifyField<int8_t>(verifier, 4) &&
774 VerifyField<int32_t>(verifier, 6) &&
775 VerifyOffset(verifier, 8) &&
776 verifier.VerifyVector(inputScale()) &&
777 VerifyOffset(verifier, 10) &&
778 verifier.VerifyVector(inputZeroPoint()) &&
779 VerifyOffset(verifier, 12) &&
780 verifier.VerifyTable(outputQuantizedParam()) &&
781 verifier.EndTable();
782 }
783 QuantizedConcatT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
784 void UnPackTo(QuantizedConcatT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
785 static flatbuffers::Offset<QuantizedConcat> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedConcatT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
786 };
787
788 struct QuantizedConcatBuilder {
789 flatbuffers::FlatBufferBuilder &fbb_;
790 flatbuffers::uoffset_t start_;
add_activationTypeQuantizedConcatBuilder791 void add_activationType(FusedActivation activationType) {
792 fbb_.AddElement<int8_t>(4, static_cast<int8_t>(activationType), 0);
793 }
add_axisQuantizedConcatBuilder794 void add_axis(int32_t axis) {
795 fbb_.AddElement<int32_t>(6, axis, 0);
796 }
add_inputScaleQuantizedConcatBuilder797 void add_inputScale(flatbuffers::Offset<flatbuffers::Vector<float>> inputScale) {
798 fbb_.AddOffset(8, inputScale);
799 }
add_inputZeroPointQuantizedConcatBuilder800 void add_inputZeroPoint(flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputZeroPoint) {
801 fbb_.AddOffset(10, inputZeroPoint);
802 }
add_outputQuantizedParamQuantizedConcatBuilder803 void add_outputQuantizedParam(flatbuffers::Offset<QuantizedParam> outputQuantizedParam) {
804 fbb_.AddOffset(12, outputQuantizedParam);
805 }
QuantizedConcatBuilderQuantizedConcatBuilder806 explicit QuantizedConcatBuilder(flatbuffers::FlatBufferBuilder &_fbb)
807 : fbb_(_fbb) {
808 start_ = fbb_.StartTable();
809 }
810 QuantizedConcatBuilder &operator=(const QuantizedConcatBuilder &);
FinishQuantizedConcatBuilder811 flatbuffers::Offset<QuantizedConcat> Finish() {
812 const auto end = fbb_.EndTable(start_);
813 auto o = flatbuffers::Offset<QuantizedConcat>(end);
814 return o;
815 }
816 };
817
818 inline flatbuffers::Offset<QuantizedConcat> CreateQuantizedConcat(
819 flatbuffers::FlatBufferBuilder &_fbb,
820 FusedActivation activationType = FusedActivation_kTfLiteActNone,
821 int32_t axis = 0,
822 flatbuffers::Offset<flatbuffers::Vector<float>> inputScale = 0,
823 flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputZeroPoint = 0,
824 flatbuffers::Offset<QuantizedParam> outputQuantizedParam = 0) {
825 QuantizedConcatBuilder builder_(_fbb);
826 builder_.add_outputQuantizedParam(outputQuantizedParam);
827 builder_.add_inputZeroPoint(inputZeroPoint);
828 builder_.add_inputScale(inputScale);
829 builder_.add_axis(axis);
830 builder_.add_activationType(activationType);
831 return builder_.Finish();
832 }
833
834 flatbuffers::Offset<QuantizedConcat> CreateQuantizedConcat(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedConcatT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
835
836 struct QuantizedLogisticT : public flatbuffers::NativeTable {
837 typedef QuantizedLogistic TableType;
838 std::unique_ptr<QuantizedParamT> inputQuantizedParam;
839 std::unique_ptr<QuantizedParamT> outputQuantizedParam;
QuantizedLogisticTQuantizedLogisticT840 QuantizedLogisticT() {
841 }
842 };
843
844 struct QuantizedLogistic FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
845 typedef QuantizedLogisticT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS846 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
847 return QuantizedLogisticTypeTable();
848 }
inputQuantizedParamFLATBUFFERS_FINAL_CLASS849 const QuantizedParam *inputQuantizedParam() const {
850 return GetPointer<const QuantizedParam *>(4);
851 }
outputQuantizedParamFLATBUFFERS_FINAL_CLASS852 const QuantizedParam *outputQuantizedParam() const {
853 return GetPointer<const QuantizedParam *>(6);
854 }
VerifyFLATBUFFERS_FINAL_CLASS855 bool Verify(flatbuffers::Verifier &verifier) const {
856 return VerifyTableStart(verifier) &&
857 VerifyOffset(verifier, 4) &&
858 verifier.VerifyTable(inputQuantizedParam()) &&
859 VerifyOffset(verifier, 6) &&
860 verifier.VerifyTable(outputQuantizedParam()) &&
861 verifier.EndTable();
862 }
863 QuantizedLogisticT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
864 void UnPackTo(QuantizedLogisticT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
865 static flatbuffers::Offset<QuantizedLogistic> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedLogisticT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
866 };
867
868 struct QuantizedLogisticBuilder {
869 flatbuffers::FlatBufferBuilder &fbb_;
870 flatbuffers::uoffset_t start_;
add_inputQuantizedParamQuantizedLogisticBuilder871 void add_inputQuantizedParam(flatbuffers::Offset<QuantizedParam> inputQuantizedParam) {
872 fbb_.AddOffset(4, inputQuantizedParam);
873 }
add_outputQuantizedParamQuantizedLogisticBuilder874 void add_outputQuantizedParam(flatbuffers::Offset<QuantizedParam> outputQuantizedParam) {
875 fbb_.AddOffset(6, outputQuantizedParam);
876 }
QuantizedLogisticBuilderQuantizedLogisticBuilder877 explicit QuantizedLogisticBuilder(flatbuffers::FlatBufferBuilder &_fbb)
878 : fbb_(_fbb) {
879 start_ = fbb_.StartTable();
880 }
881 QuantizedLogisticBuilder &operator=(const QuantizedLogisticBuilder &);
FinishQuantizedLogisticBuilder882 flatbuffers::Offset<QuantizedLogistic> Finish() {
883 const auto end = fbb_.EndTable(start_);
884 auto o = flatbuffers::Offset<QuantizedLogistic>(end);
885 return o;
886 }
887 };
888
889 inline flatbuffers::Offset<QuantizedLogistic> CreateQuantizedLogistic(
890 flatbuffers::FlatBufferBuilder &_fbb,
891 flatbuffers::Offset<QuantizedParam> inputQuantizedParam = 0,
892 flatbuffers::Offset<QuantizedParam> outputQuantizedParam = 0) {
893 QuantizedLogisticBuilder builder_(_fbb);
894 builder_.add_outputQuantizedParam(outputQuantizedParam);
895 builder_.add_inputQuantizedParam(inputQuantizedParam);
896 return builder_.Finish();
897 }
898
899 flatbuffers::Offset<QuantizedLogistic> CreateQuantizedLogistic(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedLogisticT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
900
901 struct QuantizedMatMulT : public flatbuffers::NativeTable {
902 typedef QuantizedMatMul TableType;
903 bool transposeA;
904 bool transposeB;
QuantizedMatMulTQuantizedMatMulT905 QuantizedMatMulT()
906 : transposeA(false),
907 transposeB(false) {
908 }
909 };
910
911 struct QuantizedMatMul FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
912 typedef QuantizedMatMulT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS913 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
914 return QuantizedMatMulTypeTable();
915 }
transposeAFLATBUFFERS_FINAL_CLASS916 bool transposeA() const {
917 return GetField<uint8_t>(4, 0) != 0;
918 }
transposeBFLATBUFFERS_FINAL_CLASS919 bool transposeB() const {
920 return GetField<uint8_t>(6, 0) != 0;
921 }
VerifyFLATBUFFERS_FINAL_CLASS922 bool Verify(flatbuffers::Verifier &verifier) const {
923 return VerifyTableStart(verifier) &&
924 VerifyField<uint8_t>(verifier, 4) &&
925 VerifyField<uint8_t>(verifier, 6) &&
926 verifier.EndTable();
927 }
928 QuantizedMatMulT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
929 void UnPackTo(QuantizedMatMulT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
930 static flatbuffers::Offset<QuantizedMatMul> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedMatMulT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
931 };
932
933 struct QuantizedMatMulBuilder {
934 flatbuffers::FlatBufferBuilder &fbb_;
935 flatbuffers::uoffset_t start_;
add_transposeAQuantizedMatMulBuilder936 void add_transposeA(bool transposeA) {
937 fbb_.AddElement<uint8_t>(4, static_cast<uint8_t>(transposeA), 0);
938 }
add_transposeBQuantizedMatMulBuilder939 void add_transposeB(bool transposeB) {
940 fbb_.AddElement<uint8_t>(6, static_cast<uint8_t>(transposeB), 0);
941 }
QuantizedMatMulBuilderQuantizedMatMulBuilder942 explicit QuantizedMatMulBuilder(flatbuffers::FlatBufferBuilder &_fbb)
943 : fbb_(_fbb) {
944 start_ = fbb_.StartTable();
945 }
946 QuantizedMatMulBuilder &operator=(const QuantizedMatMulBuilder &);
FinishQuantizedMatMulBuilder947 flatbuffers::Offset<QuantizedMatMul> Finish() {
948 const auto end = fbb_.EndTable(start_);
949 auto o = flatbuffers::Offset<QuantizedMatMul>(end);
950 return o;
951 }
952 };
953
954 inline flatbuffers::Offset<QuantizedMatMul> CreateQuantizedMatMul(
955 flatbuffers::FlatBufferBuilder &_fbb,
956 bool transposeA = false,
957 bool transposeB = false) {
958 QuantizedMatMulBuilder builder_(_fbb);
959 builder_.add_transposeB(transposeB);
960 builder_.add_transposeA(transposeA);
961 return builder_.Finish();
962 }
963
964 flatbuffers::Offset<QuantizedMatMul> CreateQuantizedMatMul(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedMatMulT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
965
966 struct QuantizedMaxPoolT : public flatbuffers::NativeTable {
967 typedef QuantizedMaxPool TableType;
968 int32_t kernelX;
969 int32_t kernelY;
970 ModeFormat modelFormat;
971 int32_t outputActivationMax;
972 int32_t outputActivationMin;
973 PoolPadType padType;
974 int32_t padX;
975 int32_t padY;
976 int32_t strideX;
977 int32_t strideY;
978 DataType type;
QuantizedMaxPoolTQuantizedMaxPoolT979 QuantizedMaxPoolT()
980 : kernelX(0),
981 kernelY(0),
982 modelFormat(ModeFormat_TENSORFLOW),
983 outputActivationMax(0),
984 outputActivationMin(0),
985 padType(PoolPadType_CAFFE),
986 padX(0),
987 padY(0),
988 strideX(0),
989 strideY(0),
990 type(DataType_DT_INVALID) {
991 }
992 };
993
994 struct QuantizedMaxPool FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
995 typedef QuantizedMaxPoolT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS996 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
997 return QuantizedMaxPoolTypeTable();
998 }
kernelXFLATBUFFERS_FINAL_CLASS999 int32_t kernelX() const {
1000 return GetField<int32_t>(4, 0);
1001 }
kernelYFLATBUFFERS_FINAL_CLASS1002 int32_t kernelY() const {
1003 return GetField<int32_t>(6, 0);
1004 }
modelFormatFLATBUFFERS_FINAL_CLASS1005 ModeFormat modelFormat() const {
1006 return static_cast<ModeFormat>(GetField<int8_t>(8, 0));
1007 }
outputActivationMaxFLATBUFFERS_FINAL_CLASS1008 int32_t outputActivationMax() const {
1009 return GetField<int32_t>(10, 0);
1010 }
outputActivationMinFLATBUFFERS_FINAL_CLASS1011 int32_t outputActivationMin() const {
1012 return GetField<int32_t>(12, 0);
1013 }
padTypeFLATBUFFERS_FINAL_CLASS1014 PoolPadType padType() const {
1015 return static_cast<PoolPadType>(GetField<int8_t>(14, 0));
1016 }
padXFLATBUFFERS_FINAL_CLASS1017 int32_t padX() const {
1018 return GetField<int32_t>(16, 0);
1019 }
padYFLATBUFFERS_FINAL_CLASS1020 int32_t padY() const {
1021 return GetField<int32_t>(18, 0);
1022 }
strideXFLATBUFFERS_FINAL_CLASS1023 int32_t strideX() const {
1024 return GetField<int32_t>(20, 0);
1025 }
strideYFLATBUFFERS_FINAL_CLASS1026 int32_t strideY() const {
1027 return GetField<int32_t>(22, 0);
1028 }
typeFLATBUFFERS_FINAL_CLASS1029 DataType type() const {
1030 return static_cast<DataType>(GetField<int32_t>(24, 0));
1031 }
VerifyFLATBUFFERS_FINAL_CLASS1032 bool Verify(flatbuffers::Verifier &verifier) const {
1033 return VerifyTableStart(verifier) &&
1034 VerifyField<int32_t>(verifier, 4) &&
1035 VerifyField<int32_t>(verifier, 6) &&
1036 VerifyField<int8_t>(verifier, 8) &&
1037 VerifyField<int32_t>(verifier, 10) &&
1038 VerifyField<int32_t>(verifier, 12) &&
1039 VerifyField<int8_t>(verifier, 14) &&
1040 VerifyField<int32_t>(verifier, 16) &&
1041 VerifyField<int32_t>(verifier, 18) &&
1042 VerifyField<int32_t>(verifier, 20) &&
1043 VerifyField<int32_t>(verifier, 22) &&
1044 VerifyField<int32_t>(verifier, 24) &&
1045 verifier.EndTable();
1046 }
1047 QuantizedMaxPoolT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1048 void UnPackTo(QuantizedMaxPoolT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1049 static flatbuffers::Offset<QuantizedMaxPool> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedMaxPoolT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1050 };
1051
1052 struct QuantizedMaxPoolBuilder {
1053 flatbuffers::FlatBufferBuilder &fbb_;
1054 flatbuffers::uoffset_t start_;
add_kernelXQuantizedMaxPoolBuilder1055 void add_kernelX(int32_t kernelX) {
1056 fbb_.AddElement<int32_t>(4, kernelX, 0);
1057 }
add_kernelYQuantizedMaxPoolBuilder1058 void add_kernelY(int32_t kernelY) {
1059 fbb_.AddElement<int32_t>(6, kernelY, 0);
1060 }
add_modelFormatQuantizedMaxPoolBuilder1061 void add_modelFormat(ModeFormat modelFormat) {
1062 fbb_.AddElement<int8_t>(8, static_cast<int8_t>(modelFormat), 0);
1063 }
add_outputActivationMaxQuantizedMaxPoolBuilder1064 void add_outputActivationMax(int32_t outputActivationMax) {
1065 fbb_.AddElement<int32_t>(10, outputActivationMax, 0);
1066 }
add_outputActivationMinQuantizedMaxPoolBuilder1067 void add_outputActivationMin(int32_t outputActivationMin) {
1068 fbb_.AddElement<int32_t>(12, outputActivationMin, 0);
1069 }
add_padTypeQuantizedMaxPoolBuilder1070 void add_padType(PoolPadType padType) {
1071 fbb_.AddElement<int8_t>(14, static_cast<int8_t>(padType), 0);
1072 }
add_padXQuantizedMaxPoolBuilder1073 void add_padX(int32_t padX) {
1074 fbb_.AddElement<int32_t>(16, padX, 0);
1075 }
add_padYQuantizedMaxPoolBuilder1076 void add_padY(int32_t padY) {
1077 fbb_.AddElement<int32_t>(18, padY, 0);
1078 }
add_strideXQuantizedMaxPoolBuilder1079 void add_strideX(int32_t strideX) {
1080 fbb_.AddElement<int32_t>(20, strideX, 0);
1081 }
add_strideYQuantizedMaxPoolBuilder1082 void add_strideY(int32_t strideY) {
1083 fbb_.AddElement<int32_t>(22, strideY, 0);
1084 }
add_typeQuantizedMaxPoolBuilder1085 void add_type(DataType type) {
1086 fbb_.AddElement<int32_t>(24, static_cast<int32_t>(type), 0);
1087 }
QuantizedMaxPoolBuilderQuantizedMaxPoolBuilder1088 explicit QuantizedMaxPoolBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1089 : fbb_(_fbb) {
1090 start_ = fbb_.StartTable();
1091 }
1092 QuantizedMaxPoolBuilder &operator=(const QuantizedMaxPoolBuilder &);
FinishQuantizedMaxPoolBuilder1093 flatbuffers::Offset<QuantizedMaxPool> Finish() {
1094 const auto end = fbb_.EndTable(start_);
1095 auto o = flatbuffers::Offset<QuantizedMaxPool>(end);
1096 return o;
1097 }
1098 };
1099
1100 inline flatbuffers::Offset<QuantizedMaxPool> CreateQuantizedMaxPool(
1101 flatbuffers::FlatBufferBuilder &_fbb,
1102 int32_t kernelX = 0,
1103 int32_t kernelY = 0,
1104 ModeFormat modelFormat = ModeFormat_TENSORFLOW,
1105 int32_t outputActivationMax = 0,
1106 int32_t outputActivationMin = 0,
1107 PoolPadType padType = PoolPadType_CAFFE,
1108 int32_t padX = 0,
1109 int32_t padY = 0,
1110 int32_t strideX = 0,
1111 int32_t strideY = 0,
1112 DataType type = DataType_DT_INVALID) {
1113 QuantizedMaxPoolBuilder builder_(_fbb);
1114 builder_.add_type(type);
1115 builder_.add_strideY(strideY);
1116 builder_.add_strideX(strideX);
1117 builder_.add_padY(padY);
1118 builder_.add_padX(padX);
1119 builder_.add_outputActivationMin(outputActivationMin);
1120 builder_.add_outputActivationMax(outputActivationMax);
1121 builder_.add_kernelY(kernelY);
1122 builder_.add_kernelX(kernelX);
1123 builder_.add_padType(padType);
1124 builder_.add_modelFormat(modelFormat);
1125 return builder_.Finish();
1126 }
1127
1128 flatbuffers::Offset<QuantizedMaxPool> CreateQuantizedMaxPool(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedMaxPoolT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1129
1130 struct QuantizedReluT : public flatbuffers::NativeTable {
1131 typedef QuantizedRelu TableType;
1132 DataType type;
QuantizedReluTQuantizedReluT1133 QuantizedReluT()
1134 : type(DataType_DT_INVALID) {
1135 }
1136 };
1137
1138 struct QuantizedRelu FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1139 typedef QuantizedReluT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1140 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1141 return QuantizedReluTypeTable();
1142 }
typeFLATBUFFERS_FINAL_CLASS1143 DataType type() const {
1144 return static_cast<DataType>(GetField<int32_t>(4, 0));
1145 }
VerifyFLATBUFFERS_FINAL_CLASS1146 bool Verify(flatbuffers::Verifier &verifier) const {
1147 return VerifyTableStart(verifier) &&
1148 VerifyField<int32_t>(verifier, 4) &&
1149 verifier.EndTable();
1150 }
1151 QuantizedReluT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1152 void UnPackTo(QuantizedReluT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1153 static flatbuffers::Offset<QuantizedRelu> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedReluT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1154 };
1155
1156 struct QuantizedReluBuilder {
1157 flatbuffers::FlatBufferBuilder &fbb_;
1158 flatbuffers::uoffset_t start_;
add_typeQuantizedReluBuilder1159 void add_type(DataType type) {
1160 fbb_.AddElement<int32_t>(4, static_cast<int32_t>(type), 0);
1161 }
QuantizedReluBuilderQuantizedReluBuilder1162 explicit QuantizedReluBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1163 : fbb_(_fbb) {
1164 start_ = fbb_.StartTable();
1165 }
1166 QuantizedReluBuilder &operator=(const QuantizedReluBuilder &);
FinishQuantizedReluBuilder1167 flatbuffers::Offset<QuantizedRelu> Finish() {
1168 const auto end = fbb_.EndTable(start_);
1169 auto o = flatbuffers::Offset<QuantizedRelu>(end);
1170 return o;
1171 }
1172 };
1173
1174 inline flatbuffers::Offset<QuantizedRelu> CreateQuantizedRelu(
1175 flatbuffers::FlatBufferBuilder &_fbb,
1176 DataType type = DataType_DT_INVALID) {
1177 QuantizedReluBuilder builder_(_fbb);
1178 builder_.add_type(type);
1179 return builder_.Finish();
1180 }
1181
1182 flatbuffers::Offset<QuantizedRelu> CreateQuantizedRelu(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedReluT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1183
1184 struct QuantizedRelu6T : public flatbuffers::NativeTable {
1185 typedef QuantizedRelu6 TableType;
1186 DataType type;
QuantizedRelu6TQuantizedRelu6T1187 QuantizedRelu6T()
1188 : type(DataType_DT_INVALID) {
1189 }
1190 };
1191
1192 struct QuantizedRelu6 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1193 typedef QuantizedRelu6T NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1194 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1195 return QuantizedRelu6TypeTable();
1196 }
typeFLATBUFFERS_FINAL_CLASS1197 DataType type() const {
1198 return static_cast<DataType>(GetField<int32_t>(4, 0));
1199 }
VerifyFLATBUFFERS_FINAL_CLASS1200 bool Verify(flatbuffers::Verifier &verifier) const {
1201 return VerifyTableStart(verifier) &&
1202 VerifyField<int32_t>(verifier, 4) &&
1203 verifier.EndTable();
1204 }
1205 QuantizedRelu6T *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1206 void UnPackTo(QuantizedRelu6T *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1207 static flatbuffers::Offset<QuantizedRelu6> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedRelu6T* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1208 };
1209
1210 struct QuantizedRelu6Builder {
1211 flatbuffers::FlatBufferBuilder &fbb_;
1212 flatbuffers::uoffset_t start_;
add_typeQuantizedRelu6Builder1213 void add_type(DataType type) {
1214 fbb_.AddElement<int32_t>(4, static_cast<int32_t>(type), 0);
1215 }
QuantizedRelu6BuilderQuantizedRelu6Builder1216 explicit QuantizedRelu6Builder(flatbuffers::FlatBufferBuilder &_fbb)
1217 : fbb_(_fbb) {
1218 start_ = fbb_.StartTable();
1219 }
1220 QuantizedRelu6Builder &operator=(const QuantizedRelu6Builder &);
FinishQuantizedRelu6Builder1221 flatbuffers::Offset<QuantizedRelu6> Finish() {
1222 const auto end = fbb_.EndTable(start_);
1223 auto o = flatbuffers::Offset<QuantizedRelu6>(end);
1224 return o;
1225 }
1226 };
1227
1228 inline flatbuffers::Offset<QuantizedRelu6> CreateQuantizedRelu6(
1229 flatbuffers::FlatBufferBuilder &_fbb,
1230 DataType type = DataType_DT_INVALID) {
1231 QuantizedRelu6Builder builder_(_fbb);
1232 builder_.add_type(type);
1233 return builder_.Finish();
1234 }
1235
1236 flatbuffers::Offset<QuantizedRelu6> CreateQuantizedRelu6(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedRelu6T *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1237
1238 struct QuantizedReshapeT : public flatbuffers::NativeTable {
1239 typedef QuantizedReshape TableType;
1240 std::vector<int32_t> dims;
1241 ModeFormat modelFormat;
QuantizedReshapeTQuantizedReshapeT1242 QuantizedReshapeT()
1243 : modelFormat(ModeFormat_TENSORFLOW) {
1244 }
1245 };
1246
1247 struct QuantizedReshape FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1248 typedef QuantizedReshapeT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1249 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1250 return QuantizedReshapeTypeTable();
1251 }
dimsFLATBUFFERS_FINAL_CLASS1252 const flatbuffers::Vector<int32_t> *dims() const {
1253 return GetPointer<const flatbuffers::Vector<int32_t> *>(4);
1254 }
modelFormatFLATBUFFERS_FINAL_CLASS1255 ModeFormat modelFormat() const {
1256 return static_cast<ModeFormat>(GetField<int8_t>(6, 0));
1257 }
VerifyFLATBUFFERS_FINAL_CLASS1258 bool Verify(flatbuffers::Verifier &verifier) const {
1259 return VerifyTableStart(verifier) &&
1260 VerifyOffset(verifier, 4) &&
1261 verifier.VerifyVector(dims()) &&
1262 VerifyField<int8_t>(verifier, 6) &&
1263 verifier.EndTable();
1264 }
1265 QuantizedReshapeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1266 void UnPackTo(QuantizedReshapeT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1267 static flatbuffers::Offset<QuantizedReshape> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedReshapeT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1268 };
1269
1270 struct QuantizedReshapeBuilder {
1271 flatbuffers::FlatBufferBuilder &fbb_;
1272 flatbuffers::uoffset_t start_;
add_dimsQuantizedReshapeBuilder1273 void add_dims(flatbuffers::Offset<flatbuffers::Vector<int32_t>> dims) {
1274 fbb_.AddOffset(4, dims);
1275 }
add_modelFormatQuantizedReshapeBuilder1276 void add_modelFormat(ModeFormat modelFormat) {
1277 fbb_.AddElement<int8_t>(6, static_cast<int8_t>(modelFormat), 0);
1278 }
QuantizedReshapeBuilderQuantizedReshapeBuilder1279 explicit QuantizedReshapeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1280 : fbb_(_fbb) {
1281 start_ = fbb_.StartTable();
1282 }
1283 QuantizedReshapeBuilder &operator=(const QuantizedReshapeBuilder &);
FinishQuantizedReshapeBuilder1284 flatbuffers::Offset<QuantizedReshape> Finish() {
1285 const auto end = fbb_.EndTable(start_);
1286 auto o = flatbuffers::Offset<QuantizedReshape>(end);
1287 return o;
1288 }
1289 };
1290
1291 inline flatbuffers::Offset<QuantizedReshape> CreateQuantizedReshape(
1292 flatbuffers::FlatBufferBuilder &_fbb,
1293 flatbuffers::Offset<flatbuffers::Vector<int32_t>> dims = 0,
1294 ModeFormat modelFormat = ModeFormat_TENSORFLOW) {
1295 QuantizedReshapeBuilder builder_(_fbb);
1296 builder_.add_dims(dims);
1297 builder_.add_modelFormat(modelFormat);
1298 return builder_.Finish();
1299 }
1300
1301 flatbuffers::Offset<QuantizedReshape> CreateQuantizedReshape(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedReshapeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1302
1303 struct QuantizedSoftmaxT : public flatbuffers::NativeTable {
1304 typedef QuantizedSoftmax TableType;
1305 float beta;
1306 float inputScale;
QuantizedSoftmaxTQuantizedSoftmaxT1307 QuantizedSoftmaxT()
1308 : beta(0.0f),
1309 inputScale(0.0f) {
1310 }
1311 };
1312
1313 struct QuantizedSoftmax FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1314 typedef QuantizedSoftmaxT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1315 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1316 return QuantizedSoftmaxTypeTable();
1317 }
betaFLATBUFFERS_FINAL_CLASS1318 float beta() const {
1319 return GetField<float>(4, 0.0f);
1320 }
inputScaleFLATBUFFERS_FINAL_CLASS1321 float inputScale() const {
1322 return GetField<float>(6, 0.0f);
1323 }
VerifyFLATBUFFERS_FINAL_CLASS1324 bool Verify(flatbuffers::Verifier &verifier) const {
1325 return VerifyTableStart(verifier) &&
1326 VerifyField<float>(verifier, 4) &&
1327 VerifyField<float>(verifier, 6) &&
1328 verifier.EndTable();
1329 }
1330 QuantizedSoftmaxT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1331 void UnPackTo(QuantizedSoftmaxT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1332 static flatbuffers::Offset<QuantizedSoftmax> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedSoftmaxT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1333 };
1334
1335 struct QuantizedSoftmaxBuilder {
1336 flatbuffers::FlatBufferBuilder &fbb_;
1337 flatbuffers::uoffset_t start_;
add_betaQuantizedSoftmaxBuilder1338 void add_beta(float beta) {
1339 fbb_.AddElement<float>(4, beta, 0.0f);
1340 }
add_inputScaleQuantizedSoftmaxBuilder1341 void add_inputScale(float inputScale) {
1342 fbb_.AddElement<float>(6, inputScale, 0.0f);
1343 }
QuantizedSoftmaxBuilderQuantizedSoftmaxBuilder1344 explicit QuantizedSoftmaxBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1345 : fbb_(_fbb) {
1346 start_ = fbb_.StartTable();
1347 }
1348 QuantizedSoftmaxBuilder &operator=(const QuantizedSoftmaxBuilder &);
FinishQuantizedSoftmaxBuilder1349 flatbuffers::Offset<QuantizedSoftmax> Finish() {
1350 const auto end = fbb_.EndTable(start_);
1351 auto o = flatbuffers::Offset<QuantizedSoftmax>(end);
1352 return o;
1353 }
1354 };
1355
1356 inline flatbuffers::Offset<QuantizedSoftmax> CreateQuantizedSoftmax(
1357 flatbuffers::FlatBufferBuilder &_fbb,
1358 float beta = 0.0f,
1359 float inputScale = 0.0f) {
1360 QuantizedSoftmaxBuilder builder_(_fbb);
1361 builder_.add_inputScale(inputScale);
1362 builder_.add_beta(beta);
1363 return builder_.Finish();
1364 }
1365
1366 flatbuffers::Offset<QuantizedSoftmax> CreateQuantizedSoftmax(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedSoftmaxT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1367
1368 struct QuantizeV2T : public flatbuffers::NativeTable {
1369 typedef QuantizeV2 TableType;
1370 DataType type;
1371 QuantizeMode mode;
1372 QuantizeRoundMode roundMode;
QuantizeV2TQuantizeV2T1373 QuantizeV2T()
1374 : type(DataType_DT_INVALID),
1375 mode(QuantizeMode_MIN_COMBINED),
1376 roundMode(QuantizeRoundMode_HALF_AWAY_FROM_ZERO) {
1377 }
1378 };
1379
1380 struct QuantizeV2 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1381 typedef QuantizeV2T NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1382 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1383 return QuantizeV2TypeTable();
1384 }
typeFLATBUFFERS_FINAL_CLASS1385 DataType type() const {
1386 return static_cast<DataType>(GetField<int32_t>(4, 0));
1387 }
modeFLATBUFFERS_FINAL_CLASS1388 QuantizeMode mode() const {
1389 return static_cast<QuantizeMode>(GetField<int8_t>(6, 0));
1390 }
roundModeFLATBUFFERS_FINAL_CLASS1391 QuantizeRoundMode roundMode() const {
1392 return static_cast<QuantizeRoundMode>(GetField<int8_t>(8, 0));
1393 }
VerifyFLATBUFFERS_FINAL_CLASS1394 bool Verify(flatbuffers::Verifier &verifier) const {
1395 return VerifyTableStart(verifier) &&
1396 VerifyField<int32_t>(verifier, 4) &&
1397 VerifyField<int8_t>(verifier, 6) &&
1398 VerifyField<int8_t>(verifier, 8) &&
1399 verifier.EndTable();
1400 }
1401 QuantizeV2T *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1402 void UnPackTo(QuantizeV2T *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1403 static flatbuffers::Offset<QuantizeV2> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeV2T* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1404 };
1405
1406 struct QuantizeV2Builder {
1407 flatbuffers::FlatBufferBuilder &fbb_;
1408 flatbuffers::uoffset_t start_;
add_typeQuantizeV2Builder1409 void add_type(DataType type) {
1410 fbb_.AddElement<int32_t>(4, static_cast<int32_t>(type), 0);
1411 }
add_modeQuantizeV2Builder1412 void add_mode(QuantizeMode mode) {
1413 fbb_.AddElement<int8_t>(6, static_cast<int8_t>(mode), 0);
1414 }
add_roundModeQuantizeV2Builder1415 void add_roundMode(QuantizeRoundMode roundMode) {
1416 fbb_.AddElement<int8_t>(8, static_cast<int8_t>(roundMode), 0);
1417 }
QuantizeV2BuilderQuantizeV2Builder1418 explicit QuantizeV2Builder(flatbuffers::FlatBufferBuilder &_fbb)
1419 : fbb_(_fbb) {
1420 start_ = fbb_.StartTable();
1421 }
1422 QuantizeV2Builder &operator=(const QuantizeV2Builder &);
FinishQuantizeV2Builder1423 flatbuffers::Offset<QuantizeV2> Finish() {
1424 const auto end = fbb_.EndTable(start_);
1425 auto o = flatbuffers::Offset<QuantizeV2>(end);
1426 return o;
1427 }
1428 };
1429
1430 inline flatbuffers::Offset<QuantizeV2> CreateQuantizeV2(
1431 flatbuffers::FlatBufferBuilder &_fbb,
1432 DataType type = DataType_DT_INVALID,
1433 QuantizeMode mode = QuantizeMode_MIN_COMBINED,
1434 QuantizeRoundMode roundMode = QuantizeRoundMode_HALF_AWAY_FROM_ZERO) {
1435 QuantizeV2Builder builder_(_fbb);
1436 builder_.add_type(type);
1437 builder_.add_roundMode(roundMode);
1438 builder_.add_mode(mode);
1439 return builder_.Finish();
1440 }
1441
1442 flatbuffers::Offset<QuantizeV2> CreateQuantizeV2(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeV2T *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1443
1444 struct RequantizationRangeT : public flatbuffers::NativeTable {
1445 typedef RequantizationRange TableType;
RequantizationRangeTRequantizationRangeT1446 RequantizationRangeT() {
1447 }
1448 };
1449
1450 struct RequantizationRange FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1451 typedef RequantizationRangeT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1452 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1453 return RequantizationRangeTypeTable();
1454 }
VerifyFLATBUFFERS_FINAL_CLASS1455 bool Verify(flatbuffers::Verifier &verifier) const {
1456 return VerifyTableStart(verifier) &&
1457 verifier.EndTable();
1458 }
1459 RequantizationRangeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1460 void UnPackTo(RequantizationRangeT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1461 static flatbuffers::Offset<RequantizationRange> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RequantizationRangeT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1462 };
1463
1464 struct RequantizationRangeBuilder {
1465 flatbuffers::FlatBufferBuilder &fbb_;
1466 flatbuffers::uoffset_t start_;
RequantizationRangeBuilderRequantizationRangeBuilder1467 explicit RequantizationRangeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1468 : fbb_(_fbb) {
1469 start_ = fbb_.StartTable();
1470 }
1471 RequantizationRangeBuilder &operator=(const RequantizationRangeBuilder &);
FinishRequantizationRangeBuilder1472 flatbuffers::Offset<RequantizationRange> Finish() {
1473 const auto end = fbb_.EndTable(start_);
1474 auto o = flatbuffers::Offset<RequantizationRange>(end);
1475 return o;
1476 }
1477 };
1478
CreateRequantizationRange(flatbuffers::FlatBufferBuilder & _fbb)1479 inline flatbuffers::Offset<RequantizationRange> CreateRequantizationRange(
1480 flatbuffers::FlatBufferBuilder &_fbb) {
1481 RequantizationRangeBuilder builder_(_fbb);
1482 return builder_.Finish();
1483 }
1484
1485 flatbuffers::Offset<RequantizationRange> CreateRequantizationRange(flatbuffers::FlatBufferBuilder &_fbb, const RequantizationRangeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1486
1487 struct RequantizeT : public flatbuffers::NativeTable {
1488 typedef Requantize TableType;
RequantizeTRequantizeT1489 RequantizeT() {
1490 }
1491 };
1492
1493 struct Requantize FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1494 typedef RequantizeT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1495 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1496 return RequantizeTypeTable();
1497 }
VerifyFLATBUFFERS_FINAL_CLASS1498 bool Verify(flatbuffers::Verifier &verifier) const {
1499 return VerifyTableStart(verifier) &&
1500 verifier.EndTable();
1501 }
1502 RequantizeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1503 void UnPackTo(RequantizeT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1504 static flatbuffers::Offset<Requantize> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RequantizeT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1505 };
1506
1507 struct RequantizeBuilder {
1508 flatbuffers::FlatBufferBuilder &fbb_;
1509 flatbuffers::uoffset_t start_;
RequantizeBuilderRequantizeBuilder1510 explicit RequantizeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1511 : fbb_(_fbb) {
1512 start_ = fbb_.StartTable();
1513 }
1514 RequantizeBuilder &operator=(const RequantizeBuilder &);
FinishRequantizeBuilder1515 flatbuffers::Offset<Requantize> Finish() {
1516 const auto end = fbb_.EndTable(start_);
1517 auto o = flatbuffers::Offset<Requantize>(end);
1518 return o;
1519 }
1520 };
1521
CreateRequantize(flatbuffers::FlatBufferBuilder & _fbb)1522 inline flatbuffers::Offset<Requantize> CreateRequantize(
1523 flatbuffers::FlatBufferBuilder &_fbb) {
1524 RequantizeBuilder builder_(_fbb);
1525 return builder_.Finish();
1526 }
1527
1528 flatbuffers::Offset<Requantize> CreateRequantize(flatbuffers::FlatBufferBuilder &_fbb, const RequantizeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1529
1530 struct TfQuantizedConv2DT : public flatbuffers::NativeTable {
1531 typedef TfQuantizedConv2D TableType;
1532 std::vector<int32_t> bias;
1533 bool biasflag;
1534 std::unique_ptr<Convolution2DCommonT> common;
1535 std::vector<uint8_t> weight;
1536 FusedActivation activationType;
1537 int32_t multiplier;
1538 int32_t outMax;
1539 int32_t outMin;
1540 int32_t shift;
1541 std::unique_ptr<QuantizedParamT> biasQuantizedParam;
1542 int32_t depthMultiplier;
1543 std::unique_ptr<QuantizedParamT> filterQuantizedParam;
1544 std::unique_ptr<QuantizedParamT> inputQuantizedParam;
1545 ModeFormat modelFormat;
1546 std::unique_ptr<QuantizedParamT> outputQuantizedParam;
TfQuantizedConv2DTTfQuantizedConv2DT1547 TfQuantizedConv2DT()
1548 : biasflag(false),
1549 activationType(FusedActivation_kTfLiteActNone),
1550 multiplier(0),
1551 outMax(0),
1552 outMin(0),
1553 shift(0),
1554 depthMultiplier(0),
1555 modelFormat(ModeFormat_TENSORFLOW) {
1556 }
1557 };
1558
1559 struct TfQuantizedConv2D FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1560 typedef TfQuantizedConv2DT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1561 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1562 return TfQuantizedConv2DTypeTable();
1563 }
biasFLATBUFFERS_FINAL_CLASS1564 const flatbuffers::Vector<int32_t> *bias() const {
1565 return GetPointer<const flatbuffers::Vector<int32_t> *>(4);
1566 }
biasflagFLATBUFFERS_FINAL_CLASS1567 bool biasflag() const {
1568 return GetField<uint8_t>(6, 0) != 0;
1569 }
commonFLATBUFFERS_FINAL_CLASS1570 const Convolution2DCommon *common() const {
1571 return GetPointer<const Convolution2DCommon *>(8);
1572 }
weightFLATBUFFERS_FINAL_CLASS1573 const flatbuffers::Vector<uint8_t> *weight() const {
1574 return GetPointer<const flatbuffers::Vector<uint8_t> *>(10);
1575 }
activationTypeFLATBUFFERS_FINAL_CLASS1576 FusedActivation activationType() const {
1577 return static_cast<FusedActivation>(GetField<int8_t>(12, 0));
1578 }
multiplierFLATBUFFERS_FINAL_CLASS1579 int32_t multiplier() const {
1580 return GetField<int32_t>(14, 0);
1581 }
outMaxFLATBUFFERS_FINAL_CLASS1582 int32_t outMax() const {
1583 return GetField<int32_t>(16, 0);
1584 }
outMinFLATBUFFERS_FINAL_CLASS1585 int32_t outMin() const {
1586 return GetField<int32_t>(18, 0);
1587 }
shiftFLATBUFFERS_FINAL_CLASS1588 int32_t shift() const {
1589 return GetField<int32_t>(20, 0);
1590 }
biasQuantizedParamFLATBUFFERS_FINAL_CLASS1591 const QuantizedParam *biasQuantizedParam() const {
1592 return GetPointer<const QuantizedParam *>(22);
1593 }
depthMultiplierFLATBUFFERS_FINAL_CLASS1594 int32_t depthMultiplier() const {
1595 return GetField<int32_t>(24, 0);
1596 }
filterQuantizedParamFLATBUFFERS_FINAL_CLASS1597 const QuantizedParam *filterQuantizedParam() const {
1598 return GetPointer<const QuantizedParam *>(26);
1599 }
inputQuantizedParamFLATBUFFERS_FINAL_CLASS1600 const QuantizedParam *inputQuantizedParam() const {
1601 return GetPointer<const QuantizedParam *>(28);
1602 }
modelFormatFLATBUFFERS_FINAL_CLASS1603 ModeFormat modelFormat() const {
1604 return static_cast<ModeFormat>(GetField<int8_t>(30, 0));
1605 }
outputQuantizedParamFLATBUFFERS_FINAL_CLASS1606 const QuantizedParam *outputQuantizedParam() const {
1607 return GetPointer<const QuantizedParam *>(32);
1608 }
VerifyFLATBUFFERS_FINAL_CLASS1609 bool Verify(flatbuffers::Verifier &verifier) const {
1610 return VerifyTableStart(verifier) &&
1611 VerifyOffset(verifier, 4) &&
1612 verifier.VerifyVector(bias()) &&
1613 VerifyField<uint8_t>(verifier, 6) &&
1614 VerifyOffset(verifier, 8) &&
1615 verifier.VerifyTable(common()) &&
1616 VerifyOffset(verifier, 10) &&
1617 verifier.VerifyVector(weight()) &&
1618 VerifyField<int8_t>(verifier, 12) &&
1619 VerifyField<int32_t>(verifier, 14) &&
1620 VerifyField<int32_t>(verifier, 16) &&
1621 VerifyField<int32_t>(verifier, 18) &&
1622 VerifyField<int32_t>(verifier, 20) &&
1623 VerifyOffset(verifier, 22) &&
1624 verifier.VerifyTable(biasQuantizedParam()) &&
1625 VerifyField<int32_t>(verifier, 24) &&
1626 VerifyOffset(verifier, 26) &&
1627 verifier.VerifyTable(filterQuantizedParam()) &&
1628 VerifyOffset(verifier, 28) &&
1629 verifier.VerifyTable(inputQuantizedParam()) &&
1630 VerifyField<int8_t>(verifier, 30) &&
1631 VerifyOffset(verifier, 32) &&
1632 verifier.VerifyTable(outputQuantizedParam()) &&
1633 verifier.EndTable();
1634 }
1635 TfQuantizedConv2DT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1636 void UnPackTo(TfQuantizedConv2DT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1637 static flatbuffers::Offset<TfQuantizedConv2D> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TfQuantizedConv2DT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1638 };
1639
1640 struct TfQuantizedConv2DBuilder {
1641 flatbuffers::FlatBufferBuilder &fbb_;
1642 flatbuffers::uoffset_t start_;
add_biasTfQuantizedConv2DBuilder1643 void add_bias(flatbuffers::Offset<flatbuffers::Vector<int32_t>> bias) {
1644 fbb_.AddOffset(4, bias);
1645 }
add_biasflagTfQuantizedConv2DBuilder1646 void add_biasflag(bool biasflag) {
1647 fbb_.AddElement<uint8_t>(6, static_cast<uint8_t>(biasflag), 0);
1648 }
add_commonTfQuantizedConv2DBuilder1649 void add_common(flatbuffers::Offset<Convolution2DCommon> common) {
1650 fbb_.AddOffset(8, common);
1651 }
add_weightTfQuantizedConv2DBuilder1652 void add_weight(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> weight) {
1653 fbb_.AddOffset(10, weight);
1654 }
add_activationTypeTfQuantizedConv2DBuilder1655 void add_activationType(FusedActivation activationType) {
1656 fbb_.AddElement<int8_t>(12, static_cast<int8_t>(activationType), 0);
1657 }
add_multiplierTfQuantizedConv2DBuilder1658 void add_multiplier(int32_t multiplier) {
1659 fbb_.AddElement<int32_t>(14, multiplier, 0);
1660 }
add_outMaxTfQuantizedConv2DBuilder1661 void add_outMax(int32_t outMax) {
1662 fbb_.AddElement<int32_t>(16, outMax, 0);
1663 }
add_outMinTfQuantizedConv2DBuilder1664 void add_outMin(int32_t outMin) {
1665 fbb_.AddElement<int32_t>(18, outMin, 0);
1666 }
add_shiftTfQuantizedConv2DBuilder1667 void add_shift(int32_t shift) {
1668 fbb_.AddElement<int32_t>(20, shift, 0);
1669 }
add_biasQuantizedParamTfQuantizedConv2DBuilder1670 void add_biasQuantizedParam(flatbuffers::Offset<QuantizedParam> biasQuantizedParam) {
1671 fbb_.AddOffset(22, biasQuantizedParam);
1672 }
add_depthMultiplierTfQuantizedConv2DBuilder1673 void add_depthMultiplier(int32_t depthMultiplier) {
1674 fbb_.AddElement<int32_t>(24, depthMultiplier, 0);
1675 }
add_filterQuantizedParamTfQuantizedConv2DBuilder1676 void add_filterQuantizedParam(flatbuffers::Offset<QuantizedParam> filterQuantizedParam) {
1677 fbb_.AddOffset(26, filterQuantizedParam);
1678 }
add_inputQuantizedParamTfQuantizedConv2DBuilder1679 void add_inputQuantizedParam(flatbuffers::Offset<QuantizedParam> inputQuantizedParam) {
1680 fbb_.AddOffset(28, inputQuantizedParam);
1681 }
add_modelFormatTfQuantizedConv2DBuilder1682 void add_modelFormat(ModeFormat modelFormat) {
1683 fbb_.AddElement<int8_t>(30, static_cast<int8_t>(modelFormat), 0);
1684 }
add_outputQuantizedParamTfQuantizedConv2DBuilder1685 void add_outputQuantizedParam(flatbuffers::Offset<QuantizedParam> outputQuantizedParam) {
1686 fbb_.AddOffset(32, outputQuantizedParam);
1687 }
TfQuantizedConv2DBuilderTfQuantizedConv2DBuilder1688 explicit TfQuantizedConv2DBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1689 : fbb_(_fbb) {
1690 start_ = fbb_.StartTable();
1691 }
1692 TfQuantizedConv2DBuilder &operator=(const TfQuantizedConv2DBuilder &);
FinishTfQuantizedConv2DBuilder1693 flatbuffers::Offset<TfQuantizedConv2D> Finish() {
1694 const auto end = fbb_.EndTable(start_);
1695 auto o = flatbuffers::Offset<TfQuantizedConv2D>(end);
1696 return o;
1697 }
1698 };
1699
1700 inline flatbuffers::Offset<TfQuantizedConv2D> CreateTfQuantizedConv2D(
1701 flatbuffers::FlatBufferBuilder &_fbb,
1702 flatbuffers::Offset<flatbuffers::Vector<int32_t>> bias = 0,
1703 bool biasflag = false,
1704 flatbuffers::Offset<Convolution2DCommon> common = 0,
1705 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> weight = 0,
1706 FusedActivation activationType = FusedActivation_kTfLiteActNone,
1707 int32_t multiplier = 0,
1708 int32_t outMax = 0,
1709 int32_t outMin = 0,
1710 int32_t shift = 0,
1711 flatbuffers::Offset<QuantizedParam> biasQuantizedParam = 0,
1712 int32_t depthMultiplier = 0,
1713 flatbuffers::Offset<QuantizedParam> filterQuantizedParam = 0,
1714 flatbuffers::Offset<QuantizedParam> inputQuantizedParam = 0,
1715 ModeFormat modelFormat = ModeFormat_TENSORFLOW,
1716 flatbuffers::Offset<QuantizedParam> outputQuantizedParam = 0) {
1717 TfQuantizedConv2DBuilder builder_(_fbb);
1718 builder_.add_outputQuantizedParam(outputQuantizedParam);
1719 builder_.add_inputQuantizedParam(inputQuantizedParam);
1720 builder_.add_filterQuantizedParam(filterQuantizedParam);
1721 builder_.add_depthMultiplier(depthMultiplier);
1722 builder_.add_biasQuantizedParam(biasQuantizedParam);
1723 builder_.add_shift(shift);
1724 builder_.add_outMin(outMin);
1725 builder_.add_outMax(outMax);
1726 builder_.add_multiplier(multiplier);
1727 builder_.add_weight(weight);
1728 builder_.add_common(common);
1729 builder_.add_bias(bias);
1730 builder_.add_modelFormat(modelFormat);
1731 builder_.add_activationType(activationType);
1732 builder_.add_biasflag(biasflag);
1733 return builder_.Finish();
1734 }
1735
1736 flatbuffers::Offset<TfQuantizedConv2D> CreateTfQuantizedConv2D(flatbuffers::FlatBufferBuilder &_fbb, const TfQuantizedConv2DT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1737
UnPack(const flatbuffers::resolver_function_t * _resolver)1738 inline QuantizedParamT *QuantizedParam::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1739 auto _o = new QuantizedParamT();
1740 UnPackTo(_o, _resolver);
1741 return _o;
1742 }
1743
UnPackTo(QuantizedParamT * _o,const flatbuffers::resolver_function_t * _resolver)1744 inline void QuantizedParam::UnPackTo(QuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1745 (void)_o;
1746 (void)_resolver;
1747 { auto _e = zeroPoint(); _o->zeroPoint = _e; };
1748 { auto _e = scale(); _o->scale = _e; };
1749 }
1750
Pack(flatbuffers::FlatBufferBuilder & _fbb,const QuantizedParamT * _o,const flatbuffers::rehasher_function_t * _rehasher)1751 inline flatbuffers::Offset<QuantizedParam> QuantizedParam::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1752 return CreateQuantizedParam(_fbb, _o, _rehasher);
1753 }
1754
CreateQuantizedParam(flatbuffers::FlatBufferBuilder & _fbb,const QuantizedParamT * _o,const flatbuffers::rehasher_function_t * _rehasher)1755 inline flatbuffers::Offset<QuantizedParam> CreateQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1756 (void)_rehasher;
1757 (void)_o;
1758 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const QuantizedParamT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
1759 auto _zeroPoint = _o->zeroPoint;
1760 auto _scale = _o->scale;
1761 return MNN::CreateQuantizedParam(
1762 _fbb,
1763 _zeroPoint,
1764 _scale);
1765 }
1766
UnPack(const flatbuffers::resolver_function_t * _resolver)1767 inline QuantizedAddT *QuantizedAdd::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1768 auto _o = new QuantizedAddT();
1769 UnPackTo(_o, _resolver);
1770 return _o;
1771 }
1772
UnPackTo(QuantizedAddT * _o,const flatbuffers::resolver_function_t * _resolver)1773 inline void QuantizedAdd::UnPackTo(QuantizedAddT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1774 (void)_o;
1775 (void)_resolver;
1776 { auto _e = activationType(); _o->activationType = _e; };
1777 { auto _e = input1QuantizedParam(); if (_e) _o->input1QuantizedParam = std::unique_ptr<QuantizedParamT>(_e->UnPack(_resolver)); };
1778 { auto _e = input2QuantizedParam(); if (_e) _o->input2QuantizedParam = std::unique_ptr<QuantizedParamT>(_e->UnPack(_resolver)); };
1779 { auto _e = outputQuantizedParam(); if (_e) _o->outputQuantizedParam = std::unique_ptr<QuantizedParamT>(_e->UnPack(_resolver)); };
1780 }
1781
Pack(flatbuffers::FlatBufferBuilder & _fbb,const QuantizedAddT * _o,const flatbuffers::rehasher_function_t * _rehasher)1782 inline flatbuffers::Offset<QuantizedAdd> QuantizedAdd::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedAddT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1783 return CreateQuantizedAdd(_fbb, _o, _rehasher);
1784 }
1785
CreateQuantizedAdd(flatbuffers::FlatBufferBuilder & _fbb,const QuantizedAddT * _o,const flatbuffers::rehasher_function_t * _rehasher)1786 inline flatbuffers::Offset<QuantizedAdd> CreateQuantizedAdd(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedAddT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1787 (void)_rehasher;
1788 (void)_o;
1789 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const QuantizedAddT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
1790 auto _activationType = _o->activationType;
1791 auto _input1QuantizedParam = _o->input1QuantizedParam ? CreateQuantizedParam(_fbb, _o->input1QuantizedParam.get(), _rehasher) : 0;
1792 auto _input2QuantizedParam = _o->input2QuantizedParam ? CreateQuantizedParam(_fbb, _o->input2QuantizedParam.get(), _rehasher) : 0;
1793 auto _outputQuantizedParam = _o->outputQuantizedParam ? CreateQuantizedParam(_fbb, _o->outputQuantizedParam.get(), _rehasher) : 0;
1794 return MNN::CreateQuantizedAdd(
1795 _fbb,
1796 _activationType,
1797 _input1QuantizedParam,
1798 _input2QuantizedParam,
1799 _outputQuantizedParam);
1800 }
1801
UnPack(const flatbuffers::resolver_function_t * _resolver)1802 inline DequantizeT *Dequantize::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1803 auto _o = new DequantizeT();
1804 UnPackTo(_o, _resolver);
1805 return _o;
1806 }
1807
UnPackTo(DequantizeT * _o,const flatbuffers::resolver_function_t * _resolver)1808 inline void Dequantize::UnPackTo(DequantizeT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1809 (void)_o;
1810 (void)_resolver;
1811 { auto _e = inputQuantizedParam(); if (_e) _o->inputQuantizedParam = std::unique_ptr<QuantizedParamT>(_e->UnPack(_resolver)); };
1812 { auto _e = mode(); _o->mode = _e; };
1813 { auto _e = modelFormat(); _o->modelFormat = _e; };
1814 { auto _e = type(); _o->type = _e; };
1815 }
1816
Pack(flatbuffers::FlatBufferBuilder & _fbb,const DequantizeT * _o,const flatbuffers::rehasher_function_t * _rehasher)1817 inline flatbuffers::Offset<Dequantize> Dequantize::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1818 return CreateDequantize(_fbb, _o, _rehasher);
1819 }
1820
CreateDequantize(flatbuffers::FlatBufferBuilder & _fbb,const DequantizeT * _o,const flatbuffers::rehasher_function_t * _rehasher)1821 inline flatbuffers::Offset<Dequantize> CreateDequantize(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1822 (void)_rehasher;
1823 (void)_o;
1824 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DequantizeT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
1825 auto _inputQuantizedParam = _o->inputQuantizedParam ? CreateQuantizedParam(_fbb, _o->inputQuantizedParam.get(), _rehasher) : 0;
1826 auto _mode = _o->mode;
1827 auto _modelFormat = _o->modelFormat;
1828 auto _type = _o->type;
1829 return MNN::CreateDequantize(
1830 _fbb,
1831 _inputQuantizedParam,
1832 _mode,
1833 _modelFormat,
1834 _type);
1835 }
1836
UnPack(const flatbuffers::resolver_function_t * _resolver)1837 inline QuantizedAvgPoolT *QuantizedAvgPool::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1838 auto _o = new QuantizedAvgPoolT();
1839 UnPackTo(_o, _resolver);
1840 return _o;
1841 }
1842
UnPackTo(QuantizedAvgPoolT * _o,const flatbuffers::resolver_function_t * _resolver)1843 inline void QuantizedAvgPool::UnPackTo(QuantizedAvgPoolT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1844 (void)_o;
1845 (void)_resolver;
1846 { auto _e = kernelX(); _o->kernelX = _e; };
1847 { auto _e = kernelY(); _o->kernelY = _e; };
1848 { auto _e = modelFormat(); _o->modelFormat = _e; };
1849 { auto _e = outputActivationMax(); _o->outputActivationMax = _e; };
1850 { auto _e = outputActivationMin(); _o->outputActivationMin = _e; };
1851 { auto _e = padType(); _o->padType = _e; };
1852 { auto _e = padX(); _o->padX = _e; };
1853 { auto _e = padY(); _o->padY = _e; };
1854 { auto _e = strideX(); _o->strideX = _e; };
1855 { auto _e = strideY(); _o->strideY = _e; };
1856 { auto _e = type(); _o->type = _e; };
1857 }
1858
Pack(flatbuffers::FlatBufferBuilder & _fbb,const QuantizedAvgPoolT * _o,const flatbuffers::rehasher_function_t * _rehasher)1859 inline flatbuffers::Offset<QuantizedAvgPool> QuantizedAvgPool::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedAvgPoolT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1860 return CreateQuantizedAvgPool(_fbb, _o, _rehasher);
1861 }
1862
CreateQuantizedAvgPool(flatbuffers::FlatBufferBuilder & _fbb,const QuantizedAvgPoolT * _o,const flatbuffers::rehasher_function_t * _rehasher)1863 inline flatbuffers::Offset<QuantizedAvgPool> CreateQuantizedAvgPool(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedAvgPoolT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1864 (void)_rehasher;
1865 (void)_o;
1866 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const QuantizedAvgPoolT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
1867 auto _kernelX = _o->kernelX;
1868 auto _kernelY = _o->kernelY;
1869 auto _modelFormat = _o->modelFormat;
1870 auto _outputActivationMax = _o->outputActivationMax;
1871 auto _outputActivationMin = _o->outputActivationMin;
1872 auto _padType = _o->padType;
1873 auto _padX = _o->padX;
1874 auto _padY = _o->padY;
1875 auto _strideX = _o->strideX;
1876 auto _strideY = _o->strideY;
1877 auto _type = _o->type;
1878 return MNN::CreateQuantizedAvgPool(
1879 _fbb,
1880 _kernelX,
1881 _kernelY,
1882 _modelFormat,
1883 _outputActivationMax,
1884 _outputActivationMin,
1885 _padType,
1886 _padX,
1887 _padY,
1888 _strideX,
1889 _strideY,
1890 _type);
1891 }
1892
UnPack(const flatbuffers::resolver_function_t * _resolver)1893 inline QuantizedBiasAddT *QuantizedBiasAdd::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1894 auto _o = new QuantizedBiasAddT();
1895 UnPackTo(_o, _resolver);
1896 return _o;
1897 }
1898
UnPackTo(QuantizedBiasAddT * _o,const flatbuffers::resolver_function_t * _resolver)1899 inline void QuantizedBiasAdd::UnPackTo(QuantizedBiasAddT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1900 (void)_o;
1901 (void)_resolver;
1902 { auto _e = bias(); if (_e) { _o->bias.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->bias[_i] = _e->Get(_i); } } };
1903 { auto _e = inputType(); _o->inputType = _e; };
1904 { auto _e = max(); _o->max = _e; };
1905 { auto _e = min(); _o->min = _e; };
1906 { auto _e = outputType(); _o->outputType = _e; };
1907 }
1908
Pack(flatbuffers::FlatBufferBuilder & _fbb,const QuantizedBiasAddT * _o,const flatbuffers::rehasher_function_t * _rehasher)1909 inline flatbuffers::Offset<QuantizedBiasAdd> QuantizedBiasAdd::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedBiasAddT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1910 return CreateQuantizedBiasAdd(_fbb, _o, _rehasher);
1911 }
1912
CreateQuantizedBiasAdd(flatbuffers::FlatBufferBuilder & _fbb,const QuantizedBiasAddT * _o,const flatbuffers::rehasher_function_t * _rehasher)1913 inline flatbuffers::Offset<QuantizedBiasAdd> CreateQuantizedBiasAdd(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedBiasAddT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1914 (void)_rehasher;
1915 (void)_o;
1916 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const QuantizedBiasAddT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
1917 auto _bias = _o->bias.size() ? _fbb.CreateVector(_o->bias) : 0;
1918 auto _inputType = _o->inputType;
1919 auto _max = _o->max;
1920 auto _min = _o->min;
1921 auto _outputType = _o->outputType;
1922 return MNN::CreateQuantizedBiasAdd(
1923 _fbb,
1924 _bias,
1925 _inputType,
1926 _max,
1927 _min,
1928 _outputType);
1929 }
1930
UnPack(const flatbuffers::resolver_function_t * _resolver)1931 inline QuantizedConcatT *QuantizedConcat::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1932 auto _o = new QuantizedConcatT();
1933 UnPackTo(_o, _resolver);
1934 return _o;
1935 }
1936
UnPackTo(QuantizedConcatT * _o,const flatbuffers::resolver_function_t * _resolver)1937 inline void QuantizedConcat::UnPackTo(QuantizedConcatT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1938 (void)_o;
1939 (void)_resolver;
1940 { auto _e = activationType(); _o->activationType = _e; };
1941 { auto _e = axis(); _o->axis = _e; };
1942 { auto _e = inputScale(); if (_e) { _o->inputScale.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inputScale[_i] = _e->Get(_i); } } };
1943 { auto _e = inputZeroPoint(); if (_e) { _o->inputZeroPoint.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inputZeroPoint[_i] = _e->Get(_i); } } };
1944 { auto _e = outputQuantizedParam(); if (_e) _o->outputQuantizedParam = std::unique_ptr<QuantizedParamT>(_e->UnPack(_resolver)); };
1945 }
1946
Pack(flatbuffers::FlatBufferBuilder & _fbb,const QuantizedConcatT * _o,const flatbuffers::rehasher_function_t * _rehasher)1947 inline flatbuffers::Offset<QuantizedConcat> QuantizedConcat::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedConcatT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1948 return CreateQuantizedConcat(_fbb, _o, _rehasher);
1949 }
1950
CreateQuantizedConcat(flatbuffers::FlatBufferBuilder & _fbb,const QuantizedConcatT * _o,const flatbuffers::rehasher_function_t * _rehasher)1951 inline flatbuffers::Offset<QuantizedConcat> CreateQuantizedConcat(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedConcatT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1952 (void)_rehasher;
1953 (void)_o;
1954 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const QuantizedConcatT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
1955 auto _activationType = _o->activationType;
1956 auto _axis = _o->axis;
1957 auto _inputScale = _o->inputScale.size() ? _fbb.CreateVector(_o->inputScale) : 0;
1958 auto _inputZeroPoint = _o->inputZeroPoint.size() ? _fbb.CreateVector(_o->inputZeroPoint) : 0;
1959 auto _outputQuantizedParam = _o->outputQuantizedParam ? CreateQuantizedParam(_fbb, _o->outputQuantizedParam.get(), _rehasher) : 0;
1960 return MNN::CreateQuantizedConcat(
1961 _fbb,
1962 _activationType,
1963 _axis,
1964 _inputScale,
1965 _inputZeroPoint,
1966 _outputQuantizedParam);
1967 }
1968
UnPack(const flatbuffers::resolver_function_t * _resolver)1969 inline QuantizedLogisticT *QuantizedLogistic::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1970 auto _o = new QuantizedLogisticT();
1971 UnPackTo(_o, _resolver);
1972 return _o;
1973 }
1974
UnPackTo(QuantizedLogisticT * _o,const flatbuffers::resolver_function_t * _resolver)1975 inline void QuantizedLogistic::UnPackTo(QuantizedLogisticT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1976 (void)_o;
1977 (void)_resolver;
1978 { auto _e = inputQuantizedParam(); if (_e) _o->inputQuantizedParam = std::unique_ptr<QuantizedParamT>(_e->UnPack(_resolver)); };
1979 { auto _e = outputQuantizedParam(); if (_e) _o->outputQuantizedParam = std::unique_ptr<QuantizedParamT>(_e->UnPack(_resolver)); };
1980 }
1981
Pack(flatbuffers::FlatBufferBuilder & _fbb,const QuantizedLogisticT * _o,const flatbuffers::rehasher_function_t * _rehasher)1982 inline flatbuffers::Offset<QuantizedLogistic> QuantizedLogistic::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedLogisticT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1983 return CreateQuantizedLogistic(_fbb, _o, _rehasher);
1984 }
1985
CreateQuantizedLogistic(flatbuffers::FlatBufferBuilder & _fbb,const QuantizedLogisticT * _o,const flatbuffers::rehasher_function_t * _rehasher)1986 inline flatbuffers::Offset<QuantizedLogistic> CreateQuantizedLogistic(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedLogisticT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1987 (void)_rehasher;
1988 (void)_o;
1989 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const QuantizedLogisticT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
1990 auto _inputQuantizedParam = _o->inputQuantizedParam ? CreateQuantizedParam(_fbb, _o->inputQuantizedParam.get(), _rehasher) : 0;
1991 auto _outputQuantizedParam = _o->outputQuantizedParam ? CreateQuantizedParam(_fbb, _o->outputQuantizedParam.get(), _rehasher) : 0;
1992 return MNN::CreateQuantizedLogistic(
1993 _fbb,
1994 _inputQuantizedParam,
1995 _outputQuantizedParam);
1996 }
1997
UnPack(const flatbuffers::resolver_function_t * _resolver)1998 inline QuantizedMatMulT *QuantizedMatMul::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1999 auto _o = new QuantizedMatMulT();
2000 UnPackTo(_o, _resolver);
2001 return _o;
2002 }
2003
UnPackTo(QuantizedMatMulT * _o,const flatbuffers::resolver_function_t * _resolver)2004 inline void QuantizedMatMul::UnPackTo(QuantizedMatMulT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2005 (void)_o;
2006 (void)_resolver;
2007 { auto _e = transposeA(); _o->transposeA = _e; };
2008 { auto _e = transposeB(); _o->transposeB = _e; };
2009 }
2010
Pack(flatbuffers::FlatBufferBuilder & _fbb,const QuantizedMatMulT * _o,const flatbuffers::rehasher_function_t * _rehasher)2011 inline flatbuffers::Offset<QuantizedMatMul> QuantizedMatMul::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedMatMulT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2012 return CreateQuantizedMatMul(_fbb, _o, _rehasher);
2013 }
2014
CreateQuantizedMatMul(flatbuffers::FlatBufferBuilder & _fbb,const QuantizedMatMulT * _o,const flatbuffers::rehasher_function_t * _rehasher)2015 inline flatbuffers::Offset<QuantizedMatMul> CreateQuantizedMatMul(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedMatMulT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2016 (void)_rehasher;
2017 (void)_o;
2018 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const QuantizedMatMulT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2019 auto _transposeA = _o->transposeA;
2020 auto _transposeB = _o->transposeB;
2021 return MNN::CreateQuantizedMatMul(
2022 _fbb,
2023 _transposeA,
2024 _transposeB);
2025 }
2026
UnPack(const flatbuffers::resolver_function_t * _resolver)2027 inline QuantizedMaxPoolT *QuantizedMaxPool::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2028 auto _o = new QuantizedMaxPoolT();
2029 UnPackTo(_o, _resolver);
2030 return _o;
2031 }
2032
UnPackTo(QuantizedMaxPoolT * _o,const flatbuffers::resolver_function_t * _resolver)2033 inline void QuantizedMaxPool::UnPackTo(QuantizedMaxPoolT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2034 (void)_o;
2035 (void)_resolver;
2036 { auto _e = kernelX(); _o->kernelX = _e; };
2037 { auto _e = kernelY(); _o->kernelY = _e; };
2038 { auto _e = modelFormat(); _o->modelFormat = _e; };
2039 { auto _e = outputActivationMax(); _o->outputActivationMax = _e; };
2040 { auto _e = outputActivationMin(); _o->outputActivationMin = _e; };
2041 { auto _e = padType(); _o->padType = _e; };
2042 { auto _e = padX(); _o->padX = _e; };
2043 { auto _e = padY(); _o->padY = _e; };
2044 { auto _e = strideX(); _o->strideX = _e; };
2045 { auto _e = strideY(); _o->strideY = _e; };
2046 { auto _e = type(); _o->type = _e; };
2047 }
2048
Pack(flatbuffers::FlatBufferBuilder & _fbb,const QuantizedMaxPoolT * _o,const flatbuffers::rehasher_function_t * _rehasher)2049 inline flatbuffers::Offset<QuantizedMaxPool> QuantizedMaxPool::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedMaxPoolT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2050 return CreateQuantizedMaxPool(_fbb, _o, _rehasher);
2051 }
2052
CreateQuantizedMaxPool(flatbuffers::FlatBufferBuilder & _fbb,const QuantizedMaxPoolT * _o,const flatbuffers::rehasher_function_t * _rehasher)2053 inline flatbuffers::Offset<QuantizedMaxPool> CreateQuantizedMaxPool(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedMaxPoolT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2054 (void)_rehasher;
2055 (void)_o;
2056 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const QuantizedMaxPoolT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2057 auto _kernelX = _o->kernelX;
2058 auto _kernelY = _o->kernelY;
2059 auto _modelFormat = _o->modelFormat;
2060 auto _outputActivationMax = _o->outputActivationMax;
2061 auto _outputActivationMin = _o->outputActivationMin;
2062 auto _padType = _o->padType;
2063 auto _padX = _o->padX;
2064 auto _padY = _o->padY;
2065 auto _strideX = _o->strideX;
2066 auto _strideY = _o->strideY;
2067 auto _type = _o->type;
2068 return MNN::CreateQuantizedMaxPool(
2069 _fbb,
2070 _kernelX,
2071 _kernelY,
2072 _modelFormat,
2073 _outputActivationMax,
2074 _outputActivationMin,
2075 _padType,
2076 _padX,
2077 _padY,
2078 _strideX,
2079 _strideY,
2080 _type);
2081 }
2082
UnPack(const flatbuffers::resolver_function_t * _resolver)2083 inline QuantizedReluT *QuantizedRelu::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2084 auto _o = new QuantizedReluT();
2085 UnPackTo(_o, _resolver);
2086 return _o;
2087 }
2088
UnPackTo(QuantizedReluT * _o,const flatbuffers::resolver_function_t * _resolver)2089 inline void QuantizedRelu::UnPackTo(QuantizedReluT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2090 (void)_o;
2091 (void)_resolver;
2092 { auto _e = type(); _o->type = _e; };
2093 }
2094
Pack(flatbuffers::FlatBufferBuilder & _fbb,const QuantizedReluT * _o,const flatbuffers::rehasher_function_t * _rehasher)2095 inline flatbuffers::Offset<QuantizedRelu> QuantizedRelu::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedReluT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2096 return CreateQuantizedRelu(_fbb, _o, _rehasher);
2097 }
2098
CreateQuantizedRelu(flatbuffers::FlatBufferBuilder & _fbb,const QuantizedReluT * _o,const flatbuffers::rehasher_function_t * _rehasher)2099 inline flatbuffers::Offset<QuantizedRelu> CreateQuantizedRelu(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedReluT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2100 (void)_rehasher;
2101 (void)_o;
2102 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const QuantizedReluT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2103 auto _type = _o->type;
2104 return MNN::CreateQuantizedRelu(
2105 _fbb,
2106 _type);
2107 }
2108
UnPack(const flatbuffers::resolver_function_t * _resolver)2109 inline QuantizedRelu6T *QuantizedRelu6::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2110 auto _o = new QuantizedRelu6T();
2111 UnPackTo(_o, _resolver);
2112 return _o;
2113 }
2114
UnPackTo(QuantizedRelu6T * _o,const flatbuffers::resolver_function_t * _resolver)2115 inline void QuantizedRelu6::UnPackTo(QuantizedRelu6T *_o, const flatbuffers::resolver_function_t *_resolver) const {
2116 (void)_o;
2117 (void)_resolver;
2118 { auto _e = type(); _o->type = _e; };
2119 }
2120
Pack(flatbuffers::FlatBufferBuilder & _fbb,const QuantizedRelu6T * _o,const flatbuffers::rehasher_function_t * _rehasher)2121 inline flatbuffers::Offset<QuantizedRelu6> QuantizedRelu6::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedRelu6T* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2122 return CreateQuantizedRelu6(_fbb, _o, _rehasher);
2123 }
2124
CreateQuantizedRelu6(flatbuffers::FlatBufferBuilder & _fbb,const QuantizedRelu6T * _o,const flatbuffers::rehasher_function_t * _rehasher)2125 inline flatbuffers::Offset<QuantizedRelu6> CreateQuantizedRelu6(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedRelu6T *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2126 (void)_rehasher;
2127 (void)_o;
2128 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const QuantizedRelu6T* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2129 auto _type = _o->type;
2130 return MNN::CreateQuantizedRelu6(
2131 _fbb,
2132 _type);
2133 }
2134
UnPack(const flatbuffers::resolver_function_t * _resolver)2135 inline QuantizedReshapeT *QuantizedReshape::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2136 auto _o = new QuantizedReshapeT();
2137 UnPackTo(_o, _resolver);
2138 return _o;
2139 }
2140
UnPackTo(QuantizedReshapeT * _o,const flatbuffers::resolver_function_t * _resolver)2141 inline void QuantizedReshape::UnPackTo(QuantizedReshapeT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2142 (void)_o;
2143 (void)_resolver;
2144 { auto _e = dims(); if (_e) { _o->dims.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->dims[_i] = _e->Get(_i); } } };
2145 { auto _e = modelFormat(); _o->modelFormat = _e; };
2146 }
2147
Pack(flatbuffers::FlatBufferBuilder & _fbb,const QuantizedReshapeT * _o,const flatbuffers::rehasher_function_t * _rehasher)2148 inline flatbuffers::Offset<QuantizedReshape> QuantizedReshape::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedReshapeT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2149 return CreateQuantizedReshape(_fbb, _o, _rehasher);
2150 }
2151
CreateQuantizedReshape(flatbuffers::FlatBufferBuilder & _fbb,const QuantizedReshapeT * _o,const flatbuffers::rehasher_function_t * _rehasher)2152 inline flatbuffers::Offset<QuantizedReshape> CreateQuantizedReshape(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedReshapeT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2153 (void)_rehasher;
2154 (void)_o;
2155 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const QuantizedReshapeT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2156 auto _dims = _o->dims.size() ? _fbb.CreateVector(_o->dims) : 0;
2157 auto _modelFormat = _o->modelFormat;
2158 return MNN::CreateQuantizedReshape(
2159 _fbb,
2160 _dims,
2161 _modelFormat);
2162 }
2163
UnPack(const flatbuffers::resolver_function_t * _resolver)2164 inline QuantizedSoftmaxT *QuantizedSoftmax::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2165 auto _o = new QuantizedSoftmaxT();
2166 UnPackTo(_o, _resolver);
2167 return _o;
2168 }
2169
UnPackTo(QuantizedSoftmaxT * _o,const flatbuffers::resolver_function_t * _resolver)2170 inline void QuantizedSoftmax::UnPackTo(QuantizedSoftmaxT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2171 (void)_o;
2172 (void)_resolver;
2173 { auto _e = beta(); _o->beta = _e; };
2174 { auto _e = inputScale(); _o->inputScale = _e; };
2175 }
2176
Pack(flatbuffers::FlatBufferBuilder & _fbb,const QuantizedSoftmaxT * _o,const flatbuffers::rehasher_function_t * _rehasher)2177 inline flatbuffers::Offset<QuantizedSoftmax> QuantizedSoftmax::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedSoftmaxT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2178 return CreateQuantizedSoftmax(_fbb, _o, _rehasher);
2179 }
2180
CreateQuantizedSoftmax(flatbuffers::FlatBufferBuilder & _fbb,const QuantizedSoftmaxT * _o,const flatbuffers::rehasher_function_t * _rehasher)2181 inline flatbuffers::Offset<QuantizedSoftmax> CreateQuantizedSoftmax(flatbuffers::FlatBufferBuilder &_fbb, const QuantizedSoftmaxT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2182 (void)_rehasher;
2183 (void)_o;
2184 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const QuantizedSoftmaxT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2185 auto _beta = _o->beta;
2186 auto _inputScale = _o->inputScale;
2187 return MNN::CreateQuantizedSoftmax(
2188 _fbb,
2189 _beta,
2190 _inputScale);
2191 }
2192
UnPack(const flatbuffers::resolver_function_t * _resolver)2193 inline QuantizeV2T *QuantizeV2::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2194 auto _o = new QuantizeV2T();
2195 UnPackTo(_o, _resolver);
2196 return _o;
2197 }
2198
UnPackTo(QuantizeV2T * _o,const flatbuffers::resolver_function_t * _resolver)2199 inline void QuantizeV2::UnPackTo(QuantizeV2T *_o, const flatbuffers::resolver_function_t *_resolver) const {
2200 (void)_o;
2201 (void)_resolver;
2202 { auto _e = type(); _o->type = _e; };
2203 { auto _e = mode(); _o->mode = _e; };
2204 { auto _e = roundMode(); _o->roundMode = _e; };
2205 }
2206
Pack(flatbuffers::FlatBufferBuilder & _fbb,const QuantizeV2T * _o,const flatbuffers::rehasher_function_t * _rehasher)2207 inline flatbuffers::Offset<QuantizeV2> QuantizeV2::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeV2T* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2208 return CreateQuantizeV2(_fbb, _o, _rehasher);
2209 }
2210
CreateQuantizeV2(flatbuffers::FlatBufferBuilder & _fbb,const QuantizeV2T * _o,const flatbuffers::rehasher_function_t * _rehasher)2211 inline flatbuffers::Offset<QuantizeV2> CreateQuantizeV2(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeV2T *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2212 (void)_rehasher;
2213 (void)_o;
2214 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const QuantizeV2T* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2215 auto _type = _o->type;
2216 auto _mode = _o->mode;
2217 auto _roundMode = _o->roundMode;
2218 return MNN::CreateQuantizeV2(
2219 _fbb,
2220 _type,
2221 _mode,
2222 _roundMode);
2223 }
2224
UnPack(const flatbuffers::resolver_function_t * _resolver)2225 inline RequantizationRangeT *RequantizationRange::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2226 auto _o = new RequantizationRangeT();
2227 UnPackTo(_o, _resolver);
2228 return _o;
2229 }
2230
UnPackTo(RequantizationRangeT * _o,const flatbuffers::resolver_function_t * _resolver)2231 inline void RequantizationRange::UnPackTo(RequantizationRangeT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2232 (void)_o;
2233 (void)_resolver;
2234 }
2235
Pack(flatbuffers::FlatBufferBuilder & _fbb,const RequantizationRangeT * _o,const flatbuffers::rehasher_function_t * _rehasher)2236 inline flatbuffers::Offset<RequantizationRange> RequantizationRange::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RequantizationRangeT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2237 return CreateRequantizationRange(_fbb, _o, _rehasher);
2238 }
2239
CreateRequantizationRange(flatbuffers::FlatBufferBuilder & _fbb,const RequantizationRangeT * _o,const flatbuffers::rehasher_function_t * _rehasher)2240 inline flatbuffers::Offset<RequantizationRange> CreateRequantizationRange(flatbuffers::FlatBufferBuilder &_fbb, const RequantizationRangeT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2241 (void)_rehasher;
2242 (void)_o;
2243 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RequantizationRangeT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2244 return MNN::CreateRequantizationRange(
2245 _fbb);
2246 }
2247
UnPack(const flatbuffers::resolver_function_t * _resolver)2248 inline RequantizeT *Requantize::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2249 auto _o = new RequantizeT();
2250 UnPackTo(_o, _resolver);
2251 return _o;
2252 }
2253
UnPackTo(RequantizeT * _o,const flatbuffers::resolver_function_t * _resolver)2254 inline void Requantize::UnPackTo(RequantizeT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2255 (void)_o;
2256 (void)_resolver;
2257 }
2258
Pack(flatbuffers::FlatBufferBuilder & _fbb,const RequantizeT * _o,const flatbuffers::rehasher_function_t * _rehasher)2259 inline flatbuffers::Offset<Requantize> Requantize::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RequantizeT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2260 return CreateRequantize(_fbb, _o, _rehasher);
2261 }
2262
CreateRequantize(flatbuffers::FlatBufferBuilder & _fbb,const RequantizeT * _o,const flatbuffers::rehasher_function_t * _rehasher)2263 inline flatbuffers::Offset<Requantize> CreateRequantize(flatbuffers::FlatBufferBuilder &_fbb, const RequantizeT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2264 (void)_rehasher;
2265 (void)_o;
2266 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RequantizeT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2267 return MNN::CreateRequantize(
2268 _fbb);
2269 }
2270
UnPack(const flatbuffers::resolver_function_t * _resolver)2271 inline TfQuantizedConv2DT *TfQuantizedConv2D::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2272 auto _o = new TfQuantizedConv2DT();
2273 UnPackTo(_o, _resolver);
2274 return _o;
2275 }
2276
UnPackTo(TfQuantizedConv2DT * _o,const flatbuffers::resolver_function_t * _resolver)2277 inline void TfQuantizedConv2D::UnPackTo(TfQuantizedConv2DT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2278 (void)_o;
2279 (void)_resolver;
2280 { auto _e = bias(); if (_e) { _o->bias.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->bias[_i] = _e->Get(_i); } } };
2281 { auto _e = biasflag(); _o->biasflag = _e; };
2282 { auto _e = common(); if (_e) _o->common = std::unique_ptr<Convolution2DCommonT>(_e->UnPack(_resolver)); };
2283 { auto _e = weight(); if (_e) { _o->weight.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->weight[_i] = _e->Get(_i); } } };
2284 { auto _e = activationType(); _o->activationType = _e; };
2285 { auto _e = multiplier(); _o->multiplier = _e; };
2286 { auto _e = outMax(); _o->outMax = _e; };
2287 { auto _e = outMin(); _o->outMin = _e; };
2288 { auto _e = shift(); _o->shift = _e; };
2289 { auto _e = biasQuantizedParam(); if (_e) _o->biasQuantizedParam = std::unique_ptr<QuantizedParamT>(_e->UnPack(_resolver)); };
2290 { auto _e = depthMultiplier(); _o->depthMultiplier = _e; };
2291 { auto _e = filterQuantizedParam(); if (_e) _o->filterQuantizedParam = std::unique_ptr<QuantizedParamT>(_e->UnPack(_resolver)); };
2292 { auto _e = inputQuantizedParam(); if (_e) _o->inputQuantizedParam = std::unique_ptr<QuantizedParamT>(_e->UnPack(_resolver)); };
2293 { auto _e = modelFormat(); _o->modelFormat = _e; };
2294 { auto _e = outputQuantizedParam(); if (_e) _o->outputQuantizedParam = std::unique_ptr<QuantizedParamT>(_e->UnPack(_resolver)); };
2295 }
2296
Pack(flatbuffers::FlatBufferBuilder & _fbb,const TfQuantizedConv2DT * _o,const flatbuffers::rehasher_function_t * _rehasher)2297 inline flatbuffers::Offset<TfQuantizedConv2D> TfQuantizedConv2D::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TfQuantizedConv2DT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2298 return CreateTfQuantizedConv2D(_fbb, _o, _rehasher);
2299 }
2300
CreateTfQuantizedConv2D(flatbuffers::FlatBufferBuilder & _fbb,const TfQuantizedConv2DT * _o,const flatbuffers::rehasher_function_t * _rehasher)2301 inline flatbuffers::Offset<TfQuantizedConv2D> CreateTfQuantizedConv2D(flatbuffers::FlatBufferBuilder &_fbb, const TfQuantizedConv2DT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2302 (void)_rehasher;
2303 (void)_o;
2304 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TfQuantizedConv2DT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2305 auto _bias = _o->bias.size() ? _fbb.CreateVector(_o->bias) : 0;
2306 auto _biasflag = _o->biasflag;
2307 auto _common = _o->common ? CreateConvolution2DCommon(_fbb, _o->common.get(), _rehasher) : 0;
2308 auto _weight = _o->weight.size() ? _fbb.CreateVector(_o->weight) : 0;
2309 auto _activationType = _o->activationType;
2310 auto _multiplier = _o->multiplier;
2311 auto _outMax = _o->outMax;
2312 auto _outMin = _o->outMin;
2313 auto _shift = _o->shift;
2314 auto _biasQuantizedParam = _o->biasQuantizedParam ? CreateQuantizedParam(_fbb, _o->biasQuantizedParam.get(), _rehasher) : 0;
2315 auto _depthMultiplier = _o->depthMultiplier;
2316 auto _filterQuantizedParam = _o->filterQuantizedParam ? CreateQuantizedParam(_fbb, _o->filterQuantizedParam.get(), _rehasher) : 0;
2317 auto _inputQuantizedParam = _o->inputQuantizedParam ? CreateQuantizedParam(_fbb, _o->inputQuantizedParam.get(), _rehasher) : 0;
2318 auto _modelFormat = _o->modelFormat;
2319 auto _outputQuantizedParam = _o->outputQuantizedParam ? CreateQuantizedParam(_fbb, _o->outputQuantizedParam.get(), _rehasher) : 0;
2320 return MNN::CreateTfQuantizedConv2D(
2321 _fbb,
2322 _bias,
2323 _biasflag,
2324 _common,
2325 _weight,
2326 _activationType,
2327 _multiplier,
2328 _outMax,
2329 _outMin,
2330 _shift,
2331 _biasQuantizedParam,
2332 _depthMultiplier,
2333 _filterQuantizedParam,
2334 _inputQuantizedParam,
2335 _modelFormat,
2336 _outputQuantizedParam);
2337 }
2338
FusedActivationTypeTable()2339 inline const flatbuffers::TypeTable *FusedActivationTypeTable() {
2340 static const flatbuffers::TypeCode type_codes[] = {
2341 { flatbuffers::ET_CHAR, 0, 0 },
2342 { flatbuffers::ET_CHAR, 0, 0 },
2343 { flatbuffers::ET_CHAR, 0, 0 },
2344 { flatbuffers::ET_CHAR, 0, 0 },
2345 { flatbuffers::ET_CHAR, 0, 0 },
2346 { flatbuffers::ET_CHAR, 0, 0 },
2347 { flatbuffers::ET_CHAR, 0, 0 }
2348 };
2349 static const flatbuffers::TypeFunction type_refs[] = {
2350 FusedActivationTypeTable
2351 };
2352 static const char * const names[] = {
2353 "kTfLiteActNone",
2354 "kTfLiteActRelu",
2355 "kTfLiteActRelu1",
2356 "kTfLiteActRelu6",
2357 "kTfLiteActTanh",
2358 "kTfLiteActSignBit",
2359 "kTfLiteActSigmoid"
2360 };
2361 static const flatbuffers::TypeTable tt = {
2362 flatbuffers::ST_ENUM, 7, type_codes, type_refs, nullptr, names
2363 };
2364 return &tt;
2365 }
2366
ModeFormatTypeTable()2367 inline const flatbuffers::TypeTable *ModeFormatTypeTable() {
2368 static const flatbuffers::TypeCode type_codes[] = {
2369 { flatbuffers::ET_CHAR, 0, 0 },
2370 { flatbuffers::ET_CHAR, 0, 0 }
2371 };
2372 static const flatbuffers::TypeFunction type_refs[] = {
2373 ModeFormatTypeTable
2374 };
2375 static const char * const names[] = {
2376 "TENSORFLOW",
2377 "TFLITE"
2378 };
2379 static const flatbuffers::TypeTable tt = {
2380 flatbuffers::ST_ENUM, 2, type_codes, type_refs, nullptr, names
2381 };
2382 return &tt;
2383 }
2384
QuantizeModeTypeTable()2385 inline const flatbuffers::TypeTable *QuantizeModeTypeTable() {
2386 static const flatbuffers::TypeCode type_codes[] = {
2387 { flatbuffers::ET_CHAR, 0, 0 },
2388 { flatbuffers::ET_CHAR, 0, 0 },
2389 { flatbuffers::ET_CHAR, 0, 0 }
2390 };
2391 static const flatbuffers::TypeFunction type_refs[] = {
2392 QuantizeModeTypeTable
2393 };
2394 static const char * const names[] = {
2395 "MIN_COMBINED",
2396 "MIN_FIRST",
2397 "SCALED"
2398 };
2399 static const flatbuffers::TypeTable tt = {
2400 flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, names
2401 };
2402 return &tt;
2403 }
2404
QuantizeRoundModeTypeTable()2405 inline const flatbuffers::TypeTable *QuantizeRoundModeTypeTable() {
2406 static const flatbuffers::TypeCode type_codes[] = {
2407 { flatbuffers::ET_CHAR, 0, 0 },
2408 { flatbuffers::ET_CHAR, 0, 0 }
2409 };
2410 static const flatbuffers::TypeFunction type_refs[] = {
2411 QuantizeRoundModeTypeTable
2412 };
2413 static const char * const names[] = {
2414 "HALF_AWAY_FROM_ZERO",
2415 "HALF_TO_EVEN"
2416 };
2417 static const flatbuffers::TypeTable tt = {
2418 flatbuffers::ST_ENUM, 2, type_codes, type_refs, nullptr, names
2419 };
2420 return &tt;
2421 }
2422
QuantizedParamTypeTable()2423 inline const flatbuffers::TypeTable *QuantizedParamTypeTable() {
2424 static const flatbuffers::TypeCode type_codes[] = {
2425 { flatbuffers::ET_INT, 0, -1 },
2426 { flatbuffers::ET_FLOAT, 0, -1 }
2427 };
2428 static const char * const names[] = {
2429 "zeroPoint",
2430 "scale"
2431 };
2432 static const flatbuffers::TypeTable tt = {
2433 flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, names
2434 };
2435 return &tt;
2436 }
2437
QuantizedAddTypeTable()2438 inline const flatbuffers::TypeTable *QuantizedAddTypeTable() {
2439 static const flatbuffers::TypeCode type_codes[] = {
2440 { flatbuffers::ET_CHAR, 0, 0 },
2441 { flatbuffers::ET_SEQUENCE, 0, 1 },
2442 { flatbuffers::ET_SEQUENCE, 0, 1 },
2443 { flatbuffers::ET_SEQUENCE, 0, 1 }
2444 };
2445 static const flatbuffers::TypeFunction type_refs[] = {
2446 FusedActivationTypeTable,
2447 QuantizedParamTypeTable
2448 };
2449 static const char * const names[] = {
2450 "activationType",
2451 "input1QuantizedParam",
2452 "input2QuantizedParam",
2453 "outputQuantizedParam"
2454 };
2455 static const flatbuffers::TypeTable tt = {
2456 flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, names
2457 };
2458 return &tt;
2459 }
2460
DequantizeTypeTable()2461 inline const flatbuffers::TypeTable *DequantizeTypeTable() {
2462 static const flatbuffers::TypeCode type_codes[] = {
2463 { flatbuffers::ET_SEQUENCE, 0, 0 },
2464 { flatbuffers::ET_CHAR, 0, 1 },
2465 { flatbuffers::ET_CHAR, 0, 2 },
2466 { flatbuffers::ET_INT, 0, 3 }
2467 };
2468 static const flatbuffers::TypeFunction type_refs[] = {
2469 QuantizedParamTypeTable,
2470 QuantizeModeTypeTable,
2471 ModeFormatTypeTable,
2472 DataTypeTypeTable
2473 };
2474 static const char * const names[] = {
2475 "inputQuantizedParam",
2476 "mode",
2477 "modelFormat",
2478 "type"
2479 };
2480 static const flatbuffers::TypeTable tt = {
2481 flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, names
2482 };
2483 return &tt;
2484 }
2485
QuantizedAvgPoolTypeTable()2486 inline const flatbuffers::TypeTable *QuantizedAvgPoolTypeTable() {
2487 static const flatbuffers::TypeCode type_codes[] = {
2488 { flatbuffers::ET_INT, 0, -1 },
2489 { flatbuffers::ET_INT, 0, -1 },
2490 { flatbuffers::ET_CHAR, 0, 0 },
2491 { flatbuffers::ET_INT, 0, -1 },
2492 { flatbuffers::ET_INT, 0, -1 },
2493 { flatbuffers::ET_CHAR, 0, 1 },
2494 { flatbuffers::ET_INT, 0, -1 },
2495 { flatbuffers::ET_INT, 0, -1 },
2496 { flatbuffers::ET_INT, 0, -1 },
2497 { flatbuffers::ET_INT, 0, -1 },
2498 { flatbuffers::ET_INT, 0, 2 }
2499 };
2500 static const flatbuffers::TypeFunction type_refs[] = {
2501 ModeFormatTypeTable,
2502 PoolPadTypeTypeTable,
2503 DataTypeTypeTable
2504 };
2505 static const char * const names[] = {
2506 "kernelX",
2507 "kernelY",
2508 "modelFormat",
2509 "outputActivationMax",
2510 "outputActivationMin",
2511 "padType",
2512 "padX",
2513 "padY",
2514 "strideX",
2515 "strideY",
2516 "type"
2517 };
2518 static const flatbuffers::TypeTable tt = {
2519 flatbuffers::ST_TABLE, 11, type_codes, type_refs, nullptr, names
2520 };
2521 return &tt;
2522 }
2523
QuantizedBiasAddTypeTable()2524 inline const flatbuffers::TypeTable *QuantizedBiasAddTypeTable() {
2525 static const flatbuffers::TypeCode type_codes[] = {
2526 { flatbuffers::ET_INT, 1, -1 },
2527 { flatbuffers::ET_INT, 0, 0 },
2528 { flatbuffers::ET_INT, 0, -1 },
2529 { flatbuffers::ET_INT, 0, -1 },
2530 { flatbuffers::ET_INT, 0, 0 }
2531 };
2532 static const flatbuffers::TypeFunction type_refs[] = {
2533 DataTypeTypeTable
2534 };
2535 static const char * const names[] = {
2536 "bias",
2537 "inputType",
2538 "max",
2539 "min",
2540 "outputType"
2541 };
2542 static const flatbuffers::TypeTable tt = {
2543 flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, names
2544 };
2545 return &tt;
2546 }
2547
QuantizedConcatTypeTable()2548 inline const flatbuffers::TypeTable *QuantizedConcatTypeTable() {
2549 static const flatbuffers::TypeCode type_codes[] = {
2550 { flatbuffers::ET_CHAR, 0, 0 },
2551 { flatbuffers::ET_INT, 0, -1 },
2552 { flatbuffers::ET_FLOAT, 1, -1 },
2553 { flatbuffers::ET_INT, 1, -1 },
2554 { flatbuffers::ET_SEQUENCE, 0, 1 }
2555 };
2556 static const flatbuffers::TypeFunction type_refs[] = {
2557 FusedActivationTypeTable,
2558 QuantizedParamTypeTable
2559 };
2560 static const char * const names[] = {
2561 "activationType",
2562 "axis",
2563 "inputScale",
2564 "inputZeroPoint",
2565 "outputQuantizedParam"
2566 };
2567 static const flatbuffers::TypeTable tt = {
2568 flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, names
2569 };
2570 return &tt;
2571 }
2572
QuantizedLogisticTypeTable()2573 inline const flatbuffers::TypeTable *QuantizedLogisticTypeTable() {
2574 static const flatbuffers::TypeCode type_codes[] = {
2575 { flatbuffers::ET_SEQUENCE, 0, 0 },
2576 { flatbuffers::ET_SEQUENCE, 0, 0 }
2577 };
2578 static const flatbuffers::TypeFunction type_refs[] = {
2579 QuantizedParamTypeTable
2580 };
2581 static const char * const names[] = {
2582 "inputQuantizedParam",
2583 "outputQuantizedParam"
2584 };
2585 static const flatbuffers::TypeTable tt = {
2586 flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, names
2587 };
2588 return &tt;
2589 }
2590
QuantizedMatMulTypeTable()2591 inline const flatbuffers::TypeTable *QuantizedMatMulTypeTable() {
2592 static const flatbuffers::TypeCode type_codes[] = {
2593 { flatbuffers::ET_BOOL, 0, -1 },
2594 { flatbuffers::ET_BOOL, 0, -1 }
2595 };
2596 static const char * const names[] = {
2597 "transposeA",
2598 "transposeB"
2599 };
2600 static const flatbuffers::TypeTable tt = {
2601 flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, names
2602 };
2603 return &tt;
2604 }
2605
QuantizedMaxPoolTypeTable()2606 inline const flatbuffers::TypeTable *QuantizedMaxPoolTypeTable() {
2607 static const flatbuffers::TypeCode type_codes[] = {
2608 { flatbuffers::ET_INT, 0, -1 },
2609 { flatbuffers::ET_INT, 0, -1 },
2610 { flatbuffers::ET_CHAR, 0, 0 },
2611 { flatbuffers::ET_INT, 0, -1 },
2612 { flatbuffers::ET_INT, 0, -1 },
2613 { flatbuffers::ET_CHAR, 0, 1 },
2614 { flatbuffers::ET_INT, 0, -1 },
2615 { flatbuffers::ET_INT, 0, -1 },
2616 { flatbuffers::ET_INT, 0, -1 },
2617 { flatbuffers::ET_INT, 0, -1 },
2618 { flatbuffers::ET_INT, 0, 2 }
2619 };
2620 static const flatbuffers::TypeFunction type_refs[] = {
2621 ModeFormatTypeTable,
2622 PoolPadTypeTypeTable,
2623 DataTypeTypeTable
2624 };
2625 static const char * const names[] = {
2626 "kernelX",
2627 "kernelY",
2628 "modelFormat",
2629 "outputActivationMax",
2630 "outputActivationMin",
2631 "padType",
2632 "padX",
2633 "padY",
2634 "strideX",
2635 "strideY",
2636 "type"
2637 };
2638 static const flatbuffers::TypeTable tt = {
2639 flatbuffers::ST_TABLE, 11, type_codes, type_refs, nullptr, names
2640 };
2641 return &tt;
2642 }
2643
QuantizedReluTypeTable()2644 inline const flatbuffers::TypeTable *QuantizedReluTypeTable() {
2645 static const flatbuffers::TypeCode type_codes[] = {
2646 { flatbuffers::ET_INT, 0, 0 }
2647 };
2648 static const flatbuffers::TypeFunction type_refs[] = {
2649 DataTypeTypeTable
2650 };
2651 static const char * const names[] = {
2652 "type"
2653 };
2654 static const flatbuffers::TypeTable tt = {
2655 flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, names
2656 };
2657 return &tt;
2658 }
2659
QuantizedRelu6TypeTable()2660 inline const flatbuffers::TypeTable *QuantizedRelu6TypeTable() {
2661 static const flatbuffers::TypeCode type_codes[] = {
2662 { flatbuffers::ET_INT, 0, 0 }
2663 };
2664 static const flatbuffers::TypeFunction type_refs[] = {
2665 DataTypeTypeTable
2666 };
2667 static const char * const names[] = {
2668 "type"
2669 };
2670 static const flatbuffers::TypeTable tt = {
2671 flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, names
2672 };
2673 return &tt;
2674 }
2675
QuantizedReshapeTypeTable()2676 inline const flatbuffers::TypeTable *QuantizedReshapeTypeTable() {
2677 static const flatbuffers::TypeCode type_codes[] = {
2678 { flatbuffers::ET_INT, 1, -1 },
2679 { flatbuffers::ET_CHAR, 0, 0 }
2680 };
2681 static const flatbuffers::TypeFunction type_refs[] = {
2682 ModeFormatTypeTable
2683 };
2684 static const char * const names[] = {
2685 "dims",
2686 "modelFormat"
2687 };
2688 static const flatbuffers::TypeTable tt = {
2689 flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, names
2690 };
2691 return &tt;
2692 }
2693
QuantizedSoftmaxTypeTable()2694 inline const flatbuffers::TypeTable *QuantizedSoftmaxTypeTable() {
2695 static const flatbuffers::TypeCode type_codes[] = {
2696 { flatbuffers::ET_FLOAT, 0, -1 },
2697 { flatbuffers::ET_FLOAT, 0, -1 }
2698 };
2699 static const char * const names[] = {
2700 "beta",
2701 "inputScale"
2702 };
2703 static const flatbuffers::TypeTable tt = {
2704 flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, names
2705 };
2706 return &tt;
2707 }
2708
QuantizeV2TypeTable()2709 inline const flatbuffers::TypeTable *QuantizeV2TypeTable() {
2710 static const flatbuffers::TypeCode type_codes[] = {
2711 { flatbuffers::ET_INT, 0, 0 },
2712 { flatbuffers::ET_CHAR, 0, 1 },
2713 { flatbuffers::ET_CHAR, 0, 2 }
2714 };
2715 static const flatbuffers::TypeFunction type_refs[] = {
2716 DataTypeTypeTable,
2717 QuantizeModeTypeTable,
2718 QuantizeRoundModeTypeTable
2719 };
2720 static const char * const names[] = {
2721 "type",
2722 "mode",
2723 "roundMode"
2724 };
2725 static const flatbuffers::TypeTable tt = {
2726 flatbuffers::ST_TABLE, 3, type_codes, type_refs, nullptr, names
2727 };
2728 return &tt;
2729 }
2730
RequantizationRangeTypeTable()2731 inline const flatbuffers::TypeTable *RequantizationRangeTypeTable() {
2732 static const flatbuffers::TypeTable tt = {
2733 flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr
2734 };
2735 return &tt;
2736 }
2737
RequantizeTypeTable()2738 inline const flatbuffers::TypeTable *RequantizeTypeTable() {
2739 static const flatbuffers::TypeTable tt = {
2740 flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr
2741 };
2742 return &tt;
2743 }
2744
TfQuantizedConv2DTypeTable()2745 inline const flatbuffers::TypeTable *TfQuantizedConv2DTypeTable() {
2746 static const flatbuffers::TypeCode type_codes[] = {
2747 { flatbuffers::ET_INT, 1, -1 },
2748 { flatbuffers::ET_BOOL, 0, -1 },
2749 { flatbuffers::ET_SEQUENCE, 0, 0 },
2750 { flatbuffers::ET_UCHAR, 1, -1 },
2751 { flatbuffers::ET_CHAR, 0, 1 },
2752 { flatbuffers::ET_INT, 0, -1 },
2753 { flatbuffers::ET_INT, 0, -1 },
2754 { flatbuffers::ET_INT, 0, -1 },
2755 { flatbuffers::ET_INT, 0, -1 },
2756 { flatbuffers::ET_SEQUENCE, 0, 2 },
2757 { flatbuffers::ET_INT, 0, -1 },
2758 { flatbuffers::ET_SEQUENCE, 0, 2 },
2759 { flatbuffers::ET_SEQUENCE, 0, 2 },
2760 { flatbuffers::ET_CHAR, 0, 3 },
2761 { flatbuffers::ET_SEQUENCE, 0, 2 }
2762 };
2763 static const flatbuffers::TypeFunction type_refs[] = {
2764 Convolution2DCommonTypeTable,
2765 FusedActivationTypeTable,
2766 QuantizedParamTypeTable,
2767 ModeFormatTypeTable
2768 };
2769 static const char * const names[] = {
2770 "bias",
2771 "biasflag",
2772 "common",
2773 "weight",
2774 "activationType",
2775 "multiplier",
2776 "outMax",
2777 "outMin",
2778 "shift",
2779 "biasQuantizedParam",
2780 "depthMultiplier",
2781 "filterQuantizedParam",
2782 "inputQuantizedParam",
2783 "modelFormat",
2784 "outputQuantizedParam"
2785 };
2786 static const flatbuffers::TypeTable tt = {
2787 flatbuffers::ST_TABLE, 15, type_codes, type_refs, nullptr, names
2788 };
2789 return &tt;
2790 }
2791
2792 } // namespace MNN
2793
2794 #endif // FLATBUFFERS_GENERATED_TFQUANTIZEOP_MNN_H_
2795