8 #ifndef FLATBUFFERS_GENERATED_ARMNNSCHEMA_ARMNNSERIALIZER_H_ 9 #define FLATBUFFERS_GENERATED_ARMNNSCHEMA_ARMNNSERIALIZER_H_ 11 #include "flatbuffers/flatbuffers.h" 16 struct TensorInfoBuilder;
21 struct ByteDataBuilder;
24 struct ShortDataBuilder;
27 struct IntDataBuilder;
30 struct LongDataBuilder;
33 struct ConstTensorBuilder;
36 struct InputSlotBuilder;
39 struct OutputSlotBuilder;
42 struct LayerBaseBuilder;
44 struct BindableLayerBase;
45 struct BindableLayerBaseBuilder;
48 struct AbsLayerBuilder;
50 struct ActivationLayer;
51 struct ActivationLayerBuilder;
53 struct ActivationDescriptor;
54 struct ActivationDescriptorBuilder;
57 struct AdditionLayerBuilder;
59 struct ArgMinMaxLayer;
60 struct ArgMinMaxLayerBuilder;
62 struct ArgMinMaxDescriptor;
63 struct ArgMinMaxDescriptorBuilder;
66 struct CastLayerBuilder;
68 struct ChannelShuffleLayer;
69 struct ChannelShuffleLayerBuilder;
71 struct ChannelShuffleDescriptor;
72 struct ChannelShuffleDescriptorBuilder;
74 struct ComparisonDescriptor;
75 struct ComparisonDescriptorBuilder;
77 struct ComparisonLayer;
78 struct ComparisonLayerBuilder;
81 struct ConstantLayerBuilder;
83 struct Convolution2dLayer;
84 struct Convolution2dLayerBuilder;
86 struct Convolution2dDescriptor;
87 struct Convolution2dDescriptorBuilder;
89 struct Convolution3dLayer;
90 struct Convolution3dLayerBuilder;
92 struct Convolution3dDescriptor;
93 struct Convolution3dDescriptorBuilder;
95 struct DepthToSpaceLayer;
96 struct DepthToSpaceLayerBuilder;
99 struct DepthToSpaceDescriptorBuilder;
101 struct DivisionLayer;
102 struct DivisionLayerBuilder;
104 struct ElementwiseUnaryDescriptor;
105 struct ElementwiseUnaryDescriptorBuilder;
107 struct ElementwiseUnaryLayer;
108 struct ElementwiseUnaryLayerBuilder;
111 struct EqualLayerBuilder;
114 struct FillLayerBuilder;
116 struct FillDescriptor;
117 struct FillDescriptorBuilder;
120 struct FloorLayerBuilder;
122 struct FullyConnectedLayer;
123 struct FullyConnectedLayerBuilder;
125 struct FullyConnectedDescriptor;
126 struct FullyConnectedDescriptorBuilder;
129 struct GatherLayerBuilder;
131 struct GatherDescriptor;
132 struct GatherDescriptorBuilder;
135 struct GreaterLayerBuilder;
138 struct InputLayerBuilder;
140 struct InstanceNormalizationLayer;
141 struct InstanceNormalizationLayerBuilder;
143 struct InstanceNormalizationDescriptor;
144 struct InstanceNormalizationDescriptorBuilder;
146 struct LogSoftmaxLayer;
147 struct LogSoftmaxLayerBuilder;
150 struct LogSoftmaxDescriptorBuilder;
152 struct L2NormalizationLayer;
153 struct L2NormalizationLayerBuilder;
155 struct L2NormalizationDescriptor;
156 struct L2NormalizationDescriptorBuilder;
158 struct LogicalBinaryDescriptor;
159 struct LogicalBinaryDescriptorBuilder;
161 struct LogicalBinaryLayer;
162 struct LogicalBinaryLayerBuilder;
165 struct MinimumLayerBuilder;
168 struct MaximumLayerBuilder;
170 struct MultiplicationLayer;
171 struct MultiplicationLayerBuilder;
173 struct Pooling2dLayer;
174 struct Pooling2dLayerBuilder;
176 struct Pooling3dLayer;
177 struct Pooling3dLayerBuilder;
180 struct Pooling2dDescriptorBuilder;
183 struct Pooling3dDescriptorBuilder;
185 struct QuantizeLayer;
186 struct QuantizeLayerBuilder;
189 struct SoftmaxLayerBuilder;
191 struct SoftmaxDescriptor;
192 struct SoftmaxDescriptorBuilder;
194 struct DepthwiseConvolution2dLayer;
195 struct DepthwiseConvolution2dLayerBuilder;
197 struct DepthwiseConvolution2dDescriptor;
198 struct DepthwiseConvolution2dDescriptorBuilder;
201 struct OutputLayerBuilder;
204 struct ReshapeLayerBuilder;
206 struct ReshapeDescriptor;
207 struct ReshapeDescriptorBuilder;
210 struct PermuteLayerBuilder;
212 struct PermuteDescriptor;
213 struct PermuteDescriptorBuilder;
216 struct ShapeLayerBuilder;
218 struct SpaceToBatchNdLayer;
219 struct SpaceToBatchNdLayerBuilder;
221 struct SpaceToBatchNdDescriptor;
222 struct SpaceToBatchNdDescriptorBuilder;
224 struct SpaceToDepthLayer;
225 struct SpaceToDepthLayerBuilder;
227 struct SpaceToDepthDescriptor;
228 struct SpaceToDepthDescriptorBuilder;
230 struct SubtractionLayer;
231 struct SubtractionLayerBuilder;
233 struct BatchToSpaceNdLayer;
234 struct BatchToSpaceNdLayerBuilder;
236 struct BatchToSpaceNdDescriptor;
237 struct BatchToSpaceNdDescriptorBuilder;
239 struct NormalizationLayer;
240 struct NormalizationLayerBuilder;
242 struct NormalizationDescriptor;
243 struct NormalizationDescriptorBuilder;
246 struct MeanLayerBuilder;
248 struct MeanDescriptor;
249 struct MeanDescriptorBuilder;
252 struct PadLayerBuilder;
254 struct PadDescriptor;
255 struct PadDescriptorBuilder;
258 struct RsqrtLayerBuilder;
260 struct BatchNormalizationLayer;
261 struct BatchNormalizationLayerBuilder;
263 struct BatchNormalizationDescriptor;
264 struct BatchNormalizationDescriptorBuilder;
266 struct ResizeBilinearLayer;
267 struct ResizeBilinearLayerBuilder;
269 struct ResizeBilinearDescriptor;
270 struct ResizeBilinearDescriptorBuilder;
273 struct SliceLayerBuilder;
275 struct SliceDescriptor;
276 struct SliceDescriptorBuilder;
278 struct StridedSliceLayer;
279 struct StridedSliceLayerBuilder;
281 struct StridedSliceDescriptor;
282 struct StridedSliceDescriptorBuilder;
285 struct ConcatLayerBuilder;
288 struct MergerLayerBuilder;
291 struct UintVectorBuilder;
293 struct OriginsDescriptor;
294 struct OriginsDescriptorBuilder;
296 struct ViewsDescriptor;
297 struct ViewsDescriptorBuilder;
299 struct SplitterLayer;
300 struct SplitterLayerBuilder;
302 struct DetectionPostProcessLayer;
303 struct DetectionPostProcessLayerBuilder;
305 struct DetectionPostProcessDescriptor;
306 struct DetectionPostProcessDescriptorBuilder;
308 struct LstmInputParams;
309 struct LstmInputParamsBuilder;
311 struct LstmDescriptor;
312 struct LstmDescriptorBuilder;
315 struct LstmLayerBuilder;
317 struct QLstmInputParams;
318 struct QLstmInputParamsBuilder;
320 struct QLstmDescriptor;
321 struct QLstmDescriptorBuilder;
324 struct QLstmLayerBuilder;
326 struct QuantizedLstmInputParams;
327 struct QuantizedLstmInputParamsBuilder;
329 struct QuantizedLstmLayer;
330 struct QuantizedLstmLayerBuilder;
332 struct DequantizeLayer;
333 struct DequantizeLayerBuilder;
336 struct MergeLayerBuilder;
339 struct SwitchLayerBuilder;
342 struct PreluLayerBuilder;
344 struct TransposeConvolution2dLayer;
345 struct TransposeConvolution2dLayerBuilder;
347 struct TransposeConvolution2dDescriptor;
348 struct TransposeConvolution2dDescriptorBuilder;
350 struct TransposeLayer;
351 struct TransposeLayerBuilder;
353 struct TransposeDescriptor;
354 struct TransposeDescriptorBuilder;
357 struct ResizeLayerBuilder;
359 struct ResizeDescriptor;
360 struct ResizeDescriptorBuilder;
363 struct StackLayerBuilder;
365 struct StackDescriptor;
366 struct StackDescriptorBuilder;
368 struct StandInDescriptor;
369 struct StandInDescriptorBuilder;
372 struct StandInLayerBuilder;
375 struct RankLayerBuilder;
378 struct ReduceLayerBuilder;
380 struct ReduceDescriptor;
381 struct ReduceDescriptorBuilder;
384 struct UnidirectionalSequenceLstmDescriptorBuilder;
386 struct UnidirectionalSequenceLstmLayer;
387 struct UnidirectionalSequenceLstmLayerBuilder;
390 struct AnyLayerBuilder;
392 struct FeatureCompatibilityVersions;
393 struct FeatureCompatibilityVersionsBuilder;
395 struct SerializedGraph;
396 struct SerializedGraphBuilder;
434 static const char *
const names[13] = {
454 const size_t index =
static_cast<size_t>(e);
474 static const char *
const names[3] = {
484 const size_t index =
static_cast<size_t>(e);
522 static const char *
const names[12] = {
541 const size_t index =
static_cast<size_t>(e);
565 static const char *
const names[5] = {
577 const size_t index =
static_cast<size_t>(e);
603 static const char *
const names[6] = {
616 const size_t index =
static_cast<size_t>(e);
636 static const char *
const names[3] = {
646 const size_t index =
static_cast<size_t>(e);
672 static const char *
const names[6] = {
685 const size_t index =
static_cast<size_t>(e);
710 bool VerifyConstTensorDataVector(flatbuffers::Verifier &verifier,
const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
const flatbuffers::Vector<uint8_t> *types);
858 static const char *
const names[68] = {
867 "DepthwiseConvolution2d",
882 "BatchNormalization",
892 "DetectionPostProcess",
901 "TransposeConvolution2d",
909 "InstanceNormalization",
922 "UnidirectionalSequenceLstm",
933 const size_t index =
static_cast<size_t>(e);
961 static const char *
const names[7] = {
975 const size_t index =
static_cast<size_t>(e);
1007 static const char *
const names[9] = {
1023 const size_t index =
static_cast<size_t>(e);
1043 static const char *
const names[3] = {
1053 const size_t index =
static_cast<size_t>(e);
1075 static const char *
const names[4] = {
1086 const size_t index =
static_cast<size_t>(e);
1106 static const char *
const names[3] = {
1116 const size_t index =
static_cast<size_t>(e);
1136 static const char *
const names[3] = {
1146 const size_t index =
static_cast<size_t>(e);
1166 static const char *
const names[3] = {
1176 const size_t index =
static_cast<size_t>(e);
1196 static const char *
const names[3] = {
1206 const size_t index =
static_cast<size_t>(e);
1228 static const char *
const names[4] = {
1239 const size_t index =
static_cast<size_t>(e);
1317 static const Layer values[] = {
1391 static const char *
const names[69] = {
1395 "BatchToSpaceNdLayer",
1396 "BatchNormalizationLayer",
1398 "Convolution2dLayer",
1399 "DepthwiseConvolution2dLayer",
1400 "FullyConnectedLayer",
1402 "MultiplicationLayer",
1408 "SpaceToBatchNdLayer",
1413 "NormalizationLayer",
1418 "ResizeBilinearLayer",
1420 "StridedSliceLayer",
1424 "L2NormalizationLayer",
1426 "DetectionPostProcessLayer",
1428 "QuantizedLstmLayer",
1434 "SpaceToDepthLayer",
1436 "TransposeConvolution2dLayer",
1442 "DepthToSpaceLayer",
1443 "InstanceNormalizationLayer",
1447 "ElementwiseUnaryLayer",
1452 "LogicalBinaryLayer",
1456 "UnidirectionalSequenceLstmLayer",
1457 "ChannelShuffleLayer",
1458 "Convolution3dLayer",
1467 const size_t index =
static_cast<size_t>(e);
1743 bool VerifyLayer(flatbuffers::Verifier &verifier,
const void *obj,
Layer type);
1744 bool VerifyLayerVector(flatbuffers::Verifier &verifier,
const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
const flatbuffers::Vector<uint8_t> *types);
1748 uint32_t sourceLayerIndex_;
1749 uint32_t outputSlotIndex_;
1753 memset(static_cast<void *>(
this), 0,
sizeof(Connection));
1755 Connection(uint32_t _sourceLayerIndex, uint32_t _outputSlotIndex)
1756 : sourceLayerIndex_(flatbuffers::EndianScalar(_sourceLayerIndex)),
1757 outputSlotIndex_(flatbuffers::EndianScalar(_outputSlotIndex)) {
1759 uint32_t sourceLayerIndex()
const {
1760 return flatbuffers::EndianScalar(sourceLayerIndex_);
1762 uint32_t outputSlotIndex()
const {
1763 return flatbuffers::EndianScalar(outputSlotIndex_);
1770 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1782 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_DIMENSIONS);
1806 return GetField<uint8_t>(VT_ISCONSTANT, 0) != 0;
1808 bool Verify(flatbuffers::Verifier &verifier)
const {
1809 return VerifyTableStart(verifier) &&
1811 verifier.VerifyVector(dimensions()) &&
1816 verifier.VerifyVector(quantizationScales()) &&
1820 verifier.VerifyVector(dimensionSpecificity()) &&
1821 VerifyField<uint8_t>(verifier, VT_ISCONSTANT) &&
1822 verifier.EndTable();
1828 flatbuffers::FlatBufferBuilder &
fbb_;
1855 fbb_.AddElement<uint8_t>(TensorInfo::VT_ISCONSTANT,
static_cast<uint8_t
>(isConstant), 0);
1859 start_ = fbb_.StartTable();
1863 const auto end = fbb_.EndTable(start_);
1864 auto o = flatbuffers::Offset<TensorInfo>(end);
1870 flatbuffers::FlatBufferBuilder &_fbb,
1873 float quantizationScale = 1.0f,
1874 int32_t quantizationOffset = 0,
1876 uint32_t quantizationDim = 0,
1877 uint32_t dimensionality = 1,
1879 bool isConstant =
false) {
1890 return builder_.
Finish();
1894 flatbuffers::FlatBufferBuilder &_fbb,
1895 const std::vector<uint32_t> *dimensions =
nullptr,
1897 float quantizationScale = 1.0f,
1898 int32_t quantizationOffset = 0,
1899 const std::vector<float> *quantizationScales =
nullptr,
1900 uint32_t quantizationDim = 0,
1901 uint32_t dimensionality = 1,
1902 const std::vector<uint8_t> *dimensionSpecificity =
nullptr,
1903 bool isConstant =
false) {
1904 auto dimensions__ = dimensions ? _fbb.CreateVector<uint32_t>(*dimensions) : 0;
1905 auto quantizationScales__ = quantizationScales ? _fbb.CreateVector<
float>(*quantizationScales) : 0;
1906 auto dimensionSpecificity__ = dimensionSpecificity ? _fbb.CreateVector<uint8_t>(*dimensionSpecificity) : 0;
1913 quantizationScales__,
1916 dimensionSpecificity__,
1920 struct ByteData FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
1922 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1925 const flatbuffers::Vector<int8_t> *
data()
const {
1926 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_DATA);
1928 bool Verify(flatbuffers::Verifier &verifier)
const {
1929 return VerifyTableStart(verifier) &&
1930 VerifyOffset(verifier, VT_DATA) &&
1931 verifier.VerifyVector(data()) &&
1932 verifier.EndTable();
1938 flatbuffers::FlatBufferBuilder &
fbb_;
1941 fbb_.AddOffset(ByteData::VT_DATA, data);
1945 start_ = fbb_.StartTable();
1949 const auto end = fbb_.EndTable(start_);
1950 auto o = flatbuffers::Offset<ByteData>(end);
1956 flatbuffers::FlatBufferBuilder &_fbb,
1960 return builder_.
Finish();
1964 flatbuffers::FlatBufferBuilder &_fbb,
1965 const std::vector<int8_t> *data =
nullptr) {
1966 auto data__ = data ? _fbb.CreateVector<int8_t>(*data) : 0;
1972 struct ShortData FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
1974 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1977 const flatbuffers::Vector<int16_t> *
data()
const {
1978 return GetPointer<const flatbuffers::Vector<int16_t> *>(VT_DATA);
1980 bool Verify(flatbuffers::Verifier &verifier)
const {
1981 return VerifyTableStart(verifier) &&
1982 VerifyOffset(verifier, VT_DATA) &&
1983 verifier.VerifyVector(data()) &&
1984 verifier.EndTable();
1990 flatbuffers::FlatBufferBuilder &
fbb_;
1993 fbb_.AddOffset(ShortData::VT_DATA, data);
1997 start_ = fbb_.StartTable();
2001 const auto end = fbb_.EndTable(start_);
2002 auto o = flatbuffers::Offset<ShortData>(end);
2008 flatbuffers::FlatBufferBuilder &_fbb,
2012 return builder_.
Finish();
2016 flatbuffers::FlatBufferBuilder &_fbb,
2017 const std::vector<int16_t> *data =
nullptr) {
2018 auto data__ = data ? _fbb.CreateVector<int16_t>(*data) : 0;
2024 struct IntData FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2026 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2029 const flatbuffers::Vector<int32_t> *
data()
const {
2030 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_DATA);
2032 bool Verify(flatbuffers::Verifier &verifier)
const {
2033 return VerifyTableStart(verifier) &&
2034 VerifyOffset(verifier, VT_DATA) &&
2035 verifier.VerifyVector(data()) &&
2036 verifier.EndTable();
2042 flatbuffers::FlatBufferBuilder &
fbb_;
2045 fbb_.AddOffset(IntData::VT_DATA, data);
2049 start_ = fbb_.StartTable();
2053 const auto end = fbb_.EndTable(start_);
2054 auto o = flatbuffers::Offset<IntData>(end);
2060 flatbuffers::FlatBufferBuilder &_fbb,
2064 return builder_.
Finish();
2068 flatbuffers::FlatBufferBuilder &_fbb,
2069 const std::vector<int32_t> *data =
nullptr) {
2070 auto data__ = data ? _fbb.CreateVector<int32_t>(*data) : 0;
2076 struct LongData FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2078 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2081 const flatbuffers::Vector<int64_t> *
data()
const {
2082 return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_DATA);
2084 bool Verify(flatbuffers::Verifier &verifier)
const {
2085 return VerifyTableStart(verifier) &&
2086 VerifyOffset(verifier, VT_DATA) &&
2087 verifier.VerifyVector(data()) &&
2088 verifier.EndTable();
2094 flatbuffers::FlatBufferBuilder &
fbb_;
2097 fbb_.AddOffset(LongData::VT_DATA, data);
2101 start_ = fbb_.StartTable();
2105 const auto end = fbb_.EndTable(start_);
2106 auto o = flatbuffers::Offset<LongData>(end);
2112 flatbuffers::FlatBufferBuilder &_fbb,
2116 return builder_.
Finish();
2120 flatbuffers::FlatBufferBuilder &_fbb,
2121 const std::vector<int64_t> *data =
nullptr) {
2122 auto data__ = data ? _fbb.CreateVector<int64_t>(*data) : 0;
2128 struct ConstTensor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2130 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2135 const armnnSerializer::TensorInfo *
info()
const {
2136 return GetPointer<const armnnSerializer::TensorInfo *>(
VT_INFO);
2142 return GetPointer<const void *>(VT_DATA);
2144 template<
typename T>
const T *data_as()
const;
2157 bool Verify(flatbuffers::Verifier &verifier)
const {
2158 return VerifyTableStart(verifier) &&
2159 VerifyOffset(verifier,
VT_INFO) &&
2160 verifier.VerifyTable(info()) &&
2162 VerifyOffset(verifier, VT_DATA) &&
2164 verifier.EndTable();
2168 template<>
inline const armnnSerializer::ByteData *ConstTensor::data_as<armnnSerializer::ByteData>()
const {
2169 return data_as_ByteData();
2172 template<>
inline const armnnSerializer::ShortData *ConstTensor::data_as<armnnSerializer::ShortData>()
const {
2173 return data_as_ShortData();
2176 template<>
inline const armnnSerializer::IntData *ConstTensor::data_as<armnnSerializer::IntData>()
const {
2177 return data_as_IntData();
2180 template<>
inline const armnnSerializer::LongData *ConstTensor::data_as<armnnSerializer::LongData>()
const {
2181 return data_as_LongData();
2186 flatbuffers::FlatBufferBuilder &
fbb_;
2188 void add_info(flatbuffers::Offset<armnnSerializer::TensorInfo> info) {
2195 fbb_.AddOffset(ConstTensor::VT_DATA, data);
2199 start_ = fbb_.StartTable();
2203 const auto end = fbb_.EndTable(start_);
2204 auto o = flatbuffers::Offset<ConstTensor>(end);
2210 flatbuffers::FlatBufferBuilder &_fbb,
2211 flatbuffers::Offset<armnnSerializer::TensorInfo> info = 0,
2213 flatbuffers::Offset<void> data = 0) {
2218 return builder_.
Finish();
2221 struct InputSlot FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2223 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2228 return GetField<uint32_t>(
VT_INDEX, 0);
2231 return GetStruct<const armnnSerializer::Connection *>(VT_CONNECTION);
2233 bool Verify(flatbuffers::Verifier &verifier)
const {
2234 return VerifyTableStart(verifier) &&
2235 VerifyField<uint32_t>(verifier,
VT_INDEX) &&
2236 VerifyField<armnnSerializer::Connection>(verifier, VT_CONNECTION) &&
2237 verifier.EndTable();
2243 flatbuffers::FlatBufferBuilder &
fbb_;
2249 fbb_.AddStruct(InputSlot::VT_CONNECTION, connection);
2253 start_ = fbb_.StartTable();
2257 const auto end = fbb_.EndTable(start_);
2258 auto o = flatbuffers::Offset<InputSlot>(end);
2264 flatbuffers::FlatBufferBuilder &_fbb,
2266 const armnnSerializer::Connection *connection = 0) {
2270 return builder_.
Finish();
2273 struct OutputSlot FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2275 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2280 return GetField<uint32_t>(
VT_INDEX, 0);
2283 return GetPointer<const armnnSerializer::TensorInfo *>(VT_TENSORINFO);
2285 bool Verify(flatbuffers::Verifier &verifier)
const {
2286 return VerifyTableStart(verifier) &&
2287 VerifyField<uint32_t>(verifier,
VT_INDEX) &&
2288 VerifyOffset(verifier, VT_TENSORINFO) &&
2289 verifier.VerifyTable(tensorInfo()) &&
2290 verifier.EndTable();
2296 flatbuffers::FlatBufferBuilder &
fbb_;
2302 fbb_.AddOffset(OutputSlot::VT_TENSORINFO, tensorInfo);
2306 start_ = fbb_.StartTable();
2310 const auto end = fbb_.EndTable(start_);
2311 auto o = flatbuffers::Offset<OutputSlot>(end);
2317 flatbuffers::FlatBufferBuilder &_fbb,
2319 flatbuffers::Offset<armnnSerializer::TensorInfo> tensorInfo = 0) {
2323 return builder_.
Finish();
2326 struct LayerBase FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2328 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2336 return GetField<uint32_t>(
VT_INDEX, 0);
2339 return GetPointer<const flatbuffers::String *>(
VT_LAYERNAME);
2344 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::InputSlot>> *
inputSlots()
const {
2345 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::InputSlot>> *>(
VT_INPUTSLOTS);
2347 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::OutputSlot>> *
outputSlots()
const {
2348 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::OutputSlot>> *>(VT_OUTPUTSLOTS);
2350 bool Verify(flatbuffers::Verifier &verifier)
const {
2351 return VerifyTableStart(verifier) &&
2352 VerifyField<uint32_t>(verifier,
VT_INDEX) &&
2354 verifier.VerifyString(layerName()) &&
2357 verifier.VerifyVector(inputSlots()) &&
2358 verifier.VerifyVectorOfTables(inputSlots()) &&
2359 VerifyOffset(verifier, VT_OUTPUTSLOTS) &&
2360 verifier.VerifyVector(outputSlots()) &&
2361 verifier.VerifyVectorOfTables(outputSlots()) &&
2362 verifier.EndTable();
2368 flatbuffers::FlatBufferBuilder &
fbb_;
2383 fbb_.AddOffset(LayerBase::VT_OUTPUTSLOTS, outputSlots);
2387 start_ = fbb_.StartTable();
2391 const auto end = fbb_.EndTable(start_);
2392 auto o = flatbuffers::Offset<LayerBase>(end);
2398 flatbuffers::FlatBufferBuilder &_fbb,
2400 flatbuffers::Offset<flatbuffers::String> layerName = 0,
2402 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::InputSlot>>> inputSlots = 0,
2403 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::OutputSlot>>> outputSlots = 0) {
2410 return builder_.
Finish();
2414 flatbuffers::FlatBufferBuilder &_fbb,
2416 const char *layerName =
nullptr,
2418 const std::vector<flatbuffers::Offset<armnnSerializer::InputSlot>> *inputSlots =
nullptr,
2419 const std::vector<flatbuffers::Offset<armnnSerializer::OutputSlot>> *outputSlots =
nullptr) {
2420 auto layerName__ = layerName ? _fbb.CreateString(layerName) : 0;
2421 auto inputSlots__ = inputSlots ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::InputSlot>>(*inputSlots) : 0;
2422 auto outputSlots__ = outputSlots ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::OutputSlot>>(*outputSlots) : 0;
2432 struct BindableLayerBase FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2434 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2436 VT_LAYERBINDINGID = 6
2438 const armnnSerializer::LayerBase *
base()
const {
2439 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2442 return GetField<int32_t>(VT_LAYERBINDINGID, 0);
2444 bool Verify(flatbuffers::Verifier &verifier)
const {
2445 return VerifyTableStart(verifier) &&
2446 VerifyOffset(verifier,
VT_BASE) &&
2447 verifier.VerifyTable(base()) &&
2448 VerifyField<int32_t>(verifier, VT_LAYERBINDINGID) &&
2449 verifier.EndTable();
2455 flatbuffers::FlatBufferBuilder &
fbb_;
2457 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2461 fbb_.AddElement<int32_t>(BindableLayerBase::VT_LAYERBINDINGID, layerBindingId, 0);
2465 start_ = fbb_.StartTable();
2468 flatbuffers::Offset<BindableLayerBase>
Finish() {
2469 const auto end = fbb_.EndTable(start_);
2470 auto o = flatbuffers::Offset<BindableLayerBase>(end);
2476 flatbuffers::FlatBufferBuilder &_fbb,
2477 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2478 int32_t layerBindingId = 0) {
2482 return builder_.
Finish();
2486 struct AbsLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2488 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2491 const armnnSerializer::LayerBase *
base()
const {
2492 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2494 bool Verify(flatbuffers::Verifier &verifier)
const {
2495 return VerifyTableStart(verifier) &&
2496 VerifyOffset(verifier,
VT_BASE) &&
2497 verifier.VerifyTable(base()) &&
2498 verifier.EndTable();
2504 flatbuffers::FlatBufferBuilder &
fbb_;
2506 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2511 start_ = fbb_.StartTable();
2515 const auto end = fbb_.EndTable(start_);
2516 auto o = flatbuffers::Offset<AbsLayer>(end);
2522 flatbuffers::FlatBufferBuilder &_fbb,
2523 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
2526 return builder_.
Finish();
2529 struct ActivationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2531 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2535 const armnnSerializer::LayerBase *
base()
const {
2536 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2538 const armnnSerializer::ActivationDescriptor *
descriptor()
const {
2539 return GetPointer<const armnnSerializer::ActivationDescriptor *>(
VT_DESCRIPTOR);
2541 bool Verify(flatbuffers::Verifier &verifier)
const {
2542 return VerifyTableStart(verifier) &&
2543 VerifyOffset(verifier,
VT_BASE) &&
2544 verifier.VerifyTable(base()) &&
2546 verifier.VerifyTable(descriptor()) &&
2547 verifier.EndTable();
2553 flatbuffers::FlatBufferBuilder &
fbb_;
2555 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2558 void add_descriptor(flatbuffers::Offset<armnnSerializer::ActivationDescriptor> descriptor) {
2563 start_ = fbb_.StartTable();
2566 flatbuffers::Offset<ActivationLayer>
Finish() {
2567 const auto end = fbb_.EndTable(start_);
2568 auto o = flatbuffers::Offset<ActivationLayer>(end);
2574 flatbuffers::FlatBufferBuilder &_fbb,
2575 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2576 flatbuffers::Offset<armnnSerializer::ActivationDescriptor> descriptor = 0) {
2580 return builder_.
Finish();
2583 struct ActivationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2585 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2594 return GetField<float>(
VT_A, 0.0f);
2597 return GetField<float>(VT_B, 0.0f);
2599 bool Verify(flatbuffers::Verifier &verifier)
const {
2600 return VerifyTableStart(verifier) &&
2602 VerifyField<float>(verifier,
VT_A) &&
2603 VerifyField<float>(verifier, VT_B) &&
2604 verifier.EndTable();
2610 flatbuffers::FlatBufferBuilder &
fbb_;
2619 fbb_.AddElement<
float>(ActivationDescriptor::VT_B, b, 0.0f);
2623 start_ = fbb_.StartTable();
2626 flatbuffers::Offset<ActivationDescriptor>
Finish() {
2627 const auto end = fbb_.EndTable(start_);
2628 auto o = flatbuffers::Offset<ActivationDescriptor>(end);
2634 flatbuffers::FlatBufferBuilder &_fbb,
2642 return builder_.
Finish();
2645 struct AdditionLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2647 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2650 const armnnSerializer::LayerBase *
base()
const {
2651 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2653 bool Verify(flatbuffers::Verifier &verifier)
const {
2654 return VerifyTableStart(verifier) &&
2655 VerifyOffset(verifier,
VT_BASE) &&
2656 verifier.VerifyTable(base()) &&
2657 verifier.EndTable();
2663 flatbuffers::FlatBufferBuilder &
fbb_;
2665 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2670 start_ = fbb_.StartTable();
2673 flatbuffers::Offset<AdditionLayer>
Finish() {
2674 const auto end = fbb_.EndTable(start_);
2675 auto o = flatbuffers::Offset<AdditionLayer>(end);
2681 flatbuffers::FlatBufferBuilder &_fbb,
2682 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
2685 return builder_.
Finish();
2688 struct ArgMinMaxLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2690 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2694 const armnnSerializer::LayerBase *
base()
const {
2695 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2698 return GetPointer<const armnnSerializer::ArgMinMaxDescriptor *>(
VT_DESCRIPTOR);
2700 bool Verify(flatbuffers::Verifier &verifier)
const {
2701 return VerifyTableStart(verifier) &&
2702 VerifyOffset(verifier,
VT_BASE) &&
2703 verifier.VerifyTable(base()) &&
2705 verifier.VerifyTable(descriptor()) &&
2706 verifier.EndTable();
2712 flatbuffers::FlatBufferBuilder &
fbb_;
2714 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2717 void add_descriptor(flatbuffers::Offset<armnnSerializer::ArgMinMaxDescriptor> descriptor) {
2722 start_ = fbb_.StartTable();
2725 flatbuffers::Offset<ArgMinMaxLayer>
Finish() {
2726 const auto end = fbb_.EndTable(start_);
2727 auto o = flatbuffers::Offset<ArgMinMaxLayer>(end);
2733 flatbuffers::FlatBufferBuilder &_fbb,
2734 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2735 flatbuffers::Offset<armnnSerializer::ArgMinMaxDescriptor> descriptor = 0) {
2739 return builder_.
Finish();
2742 struct ArgMinMaxDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2744 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2752 return GetField<int32_t>(
VT_AXIS, 0);
2754 bool Verify(flatbuffers::Verifier &verifier)
const {
2755 return VerifyTableStart(verifier) &&
2757 VerifyField<int32_t>(verifier,
VT_AXIS) &&
2758 verifier.EndTable();
2764 flatbuffers::FlatBufferBuilder &
fbb_;
2774 start_ = fbb_.StartTable();
2777 flatbuffers::Offset<ArgMinMaxDescriptor>
Finish() {
2778 const auto end = fbb_.EndTable(start_);
2779 auto o = flatbuffers::Offset<ArgMinMaxDescriptor>(end);
2785 flatbuffers::FlatBufferBuilder &_fbb,
2791 return builder_.
Finish();
2794 struct CastLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2796 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2799 const armnnSerializer::LayerBase *
base()
const {
2800 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2802 bool Verify(flatbuffers::Verifier &verifier)
const {
2803 return VerifyTableStart(verifier) &&
2804 VerifyOffset(verifier,
VT_BASE) &&
2805 verifier.VerifyTable(base()) &&
2806 verifier.EndTable();
2812 flatbuffers::FlatBufferBuilder &
fbb_;
2814 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2819 start_ = fbb_.StartTable();
2823 const auto end = fbb_.EndTable(start_);
2824 auto o = flatbuffers::Offset<CastLayer>(end);
2830 flatbuffers::FlatBufferBuilder &_fbb,
2831 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
2834 return builder_.
Finish();
2837 struct ChannelShuffleLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2839 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2843 const armnnSerializer::LayerBase *
base()
const {
2844 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2846 const armnnSerializer::ChannelShuffleDescriptor *
descriptor()
const {
2847 return GetPointer<const armnnSerializer::ChannelShuffleDescriptor *>(
VT_DESCRIPTOR);
2849 bool Verify(flatbuffers::Verifier &verifier)
const {
2850 return VerifyTableStart(verifier) &&
2851 VerifyOffset(verifier,
VT_BASE) &&
2852 verifier.VerifyTable(base()) &&
2854 verifier.VerifyTable(descriptor()) &&
2855 verifier.EndTable();
2861 flatbuffers::FlatBufferBuilder &
fbb_;
2863 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2866 void add_descriptor(flatbuffers::Offset<armnnSerializer::ChannelShuffleDescriptor> descriptor) {
2871 start_ = fbb_.StartTable();
2874 flatbuffers::Offset<ChannelShuffleLayer>
Finish() {
2875 const auto end = fbb_.EndTable(start_);
2876 auto o = flatbuffers::Offset<ChannelShuffleLayer>(end);
2882 flatbuffers::FlatBufferBuilder &_fbb,
2883 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2884 flatbuffers::Offset<armnnSerializer::ChannelShuffleDescriptor> descriptor = 0) {
2888 return builder_.
Finish();
2891 struct ChannelShuffleDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2893 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2898 return GetField<uint32_t>(
VT_AXIS, 0);
2901 return GetField<uint32_t>(VT_NUMGROUPS, 0);
2903 bool Verify(flatbuffers::Verifier &verifier)
const {
2904 return VerifyTableStart(verifier) &&
2905 VerifyField<uint32_t>(verifier,
VT_AXIS) &&
2906 VerifyField<uint32_t>(verifier, VT_NUMGROUPS) &&
2907 verifier.EndTable();
2913 flatbuffers::FlatBufferBuilder &
fbb_;
2919 fbb_.AddElement<uint32_t>(ChannelShuffleDescriptor::VT_NUMGROUPS, numGroups, 0);
2923 start_ = fbb_.StartTable();
2926 flatbuffers::Offset<ChannelShuffleDescriptor>
Finish() {
2927 const auto end = fbb_.EndTable(start_);
2928 auto o = flatbuffers::Offset<ChannelShuffleDescriptor>(end);
2934 flatbuffers::FlatBufferBuilder &_fbb,
2936 uint32_t numGroups = 0) {
2940 return builder_.
Finish();
2943 struct ComparisonDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2945 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2951 bool Verify(flatbuffers::Verifier &verifier)
const {
2952 return VerifyTableStart(verifier) &&
2953 VerifyField<int8_t>(verifier, VT_OPERATION) &&
2954 verifier.EndTable();
2960 flatbuffers::FlatBufferBuilder &
fbb_;
2963 fbb_.AddElement<int8_t>(ComparisonDescriptor::VT_OPERATION,
static_cast<int8_t
>(operation), 0);
2967 start_ = fbb_.StartTable();
2970 flatbuffers::Offset<ComparisonDescriptor>
Finish() {
2971 const auto end = fbb_.EndTable(start_);
2972 auto o = flatbuffers::Offset<ComparisonDescriptor>(end);
2978 flatbuffers::FlatBufferBuilder &_fbb,
2982 return builder_.
Finish();
2985 struct ComparisonLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2987 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2991 const armnnSerializer::LayerBase *
base()
const {
2992 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2994 const armnnSerializer::ComparisonDescriptor *
descriptor()
const {
2995 return GetPointer<const armnnSerializer::ComparisonDescriptor *>(
VT_DESCRIPTOR);
2997 bool Verify(flatbuffers::Verifier &verifier)
const {
2998 return VerifyTableStart(verifier) &&
2999 VerifyOffset(verifier,
VT_BASE) &&
3000 verifier.VerifyTable(base()) &&
3002 verifier.VerifyTable(descriptor()) &&
3003 verifier.EndTable();
3009 flatbuffers::FlatBufferBuilder &
fbb_;
3011 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3014 void add_descriptor(flatbuffers::Offset<armnnSerializer::ComparisonDescriptor> descriptor) {
3019 start_ = fbb_.StartTable();
3022 flatbuffers::Offset<ComparisonLayer>
Finish() {
3023 const auto end = fbb_.EndTable(start_);
3024 auto o = flatbuffers::Offset<ComparisonLayer>(end);
3030 flatbuffers::FlatBufferBuilder &_fbb,
3031 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3032 flatbuffers::Offset<armnnSerializer::ComparisonDescriptor> descriptor = 0) {
3036 return builder_.
Finish();
3039 struct ConstantLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3041 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3045 const armnnSerializer::LayerBase *
base()
const {
3046 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3048 const armnnSerializer::ConstTensor *
input()
const {
3049 return GetPointer<const armnnSerializer::ConstTensor *>(VT_INPUT);
3051 bool Verify(flatbuffers::Verifier &verifier)
const {
3052 return VerifyTableStart(verifier) &&
3053 VerifyOffset(verifier,
VT_BASE) &&
3054 verifier.VerifyTable(base()) &&
3055 VerifyOffset(verifier, VT_INPUT) &&
3056 verifier.VerifyTable(input()) &&
3057 verifier.EndTable();
3063 flatbuffers::FlatBufferBuilder &
fbb_;
3065 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3068 void add_input(flatbuffers::Offset<armnnSerializer::ConstTensor> input) {
3069 fbb_.AddOffset(ConstantLayer::VT_INPUT, input);
3073 start_ = fbb_.StartTable();
3076 flatbuffers::Offset<ConstantLayer>
Finish() {
3077 const auto end = fbb_.EndTable(start_);
3078 auto o = flatbuffers::Offset<ConstantLayer>(end);
3084 flatbuffers::FlatBufferBuilder &_fbb,
3085 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3086 flatbuffers::Offset<armnnSerializer::ConstTensor> input = 0) {
3090 return builder_.
Finish();
3093 struct Convolution2dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3095 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3101 const armnnSerializer::LayerBase *
base()
const {
3102 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3104 const armnnSerializer::Convolution2dDescriptor *
descriptor()
const {
3105 return GetPointer<const armnnSerializer::Convolution2dDescriptor *>(
VT_DESCRIPTOR);
3107 const armnnSerializer::ConstTensor *
weights()
const {
3108 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_WEIGHTS);
3110 const armnnSerializer::ConstTensor *
biases()
const {
3111 return GetPointer<const armnnSerializer::ConstTensor *>(VT_BIASES);
3113 bool Verify(flatbuffers::Verifier &verifier)
const {
3114 return VerifyTableStart(verifier) &&
3115 VerifyOffset(verifier,
VT_BASE) &&
3116 verifier.VerifyTable(base()) &&
3118 verifier.VerifyTable(descriptor()) &&
3120 verifier.VerifyTable(weights()) &&
3121 VerifyOffset(verifier, VT_BIASES) &&
3122 verifier.VerifyTable(biases()) &&
3123 verifier.EndTable();
3129 flatbuffers::FlatBufferBuilder &
fbb_;
3131 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3134 void add_descriptor(flatbuffers::Offset<armnnSerializer::Convolution2dDescriptor> descriptor) {
3137 void add_weights(flatbuffers::Offset<armnnSerializer::ConstTensor> weights) {
3140 void add_biases(flatbuffers::Offset<armnnSerializer::ConstTensor> biases) {
3141 fbb_.AddOffset(Convolution2dLayer::VT_BIASES, biases);
3145 start_ = fbb_.StartTable();
3148 flatbuffers::Offset<Convolution2dLayer>
Finish() {
3149 const auto end = fbb_.EndTable(start_);
3150 auto o = flatbuffers::Offset<Convolution2dLayer>(end);
3156 flatbuffers::FlatBufferBuilder &_fbb,
3157 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3158 flatbuffers::Offset<armnnSerializer::Convolution2dDescriptor> descriptor = 0,
3159 flatbuffers::Offset<armnnSerializer::ConstTensor> weights = 0,
3160 flatbuffers::Offset<armnnSerializer::ConstTensor> biases = 0) {
3166 return builder_.
Finish();
3169 struct Convolution2dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3171 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3190 return GetField<uint32_t>(
VT_PADTOP, 0);
3213 bool Verify(flatbuffers::Verifier &verifier)
const {
3214 return VerifyTableStart(verifier) &&
3215 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
3217 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
3219 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
3220 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
3225 verifier.EndTable();
3231 flatbuffers::FlatBufferBuilder &
fbb_;
3265 start_ = fbb_.StartTable();
3268 flatbuffers::Offset<Convolution2dDescriptor>
Finish() {
3269 const auto end = fbb_.EndTable(start_);
3270 auto o = flatbuffers::Offset<Convolution2dDescriptor>(end);
3276 flatbuffers::FlatBufferBuilder &_fbb,
3277 uint32_t padLeft = 0,
3278 uint32_t padRight = 0,
3279 uint32_t padTop = 0,
3280 uint32_t padBottom = 0,
3281 uint32_t strideX = 0,
3282 uint32_t strideY = 0,
3283 uint32_t dilationX = 1,
3284 uint32_t dilationY = 1,
3285 bool biasEnabled =
false,
3298 return builder_.
Finish();
3301 struct Convolution3dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3303 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3307 const armnnSerializer::LayerBase *
base()
const {
3308 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3310 const armnnSerializer::Convolution3dDescriptor *
descriptor()
const {
3311 return GetPointer<const armnnSerializer::Convolution3dDescriptor *>(
VT_DESCRIPTOR);
3313 bool Verify(flatbuffers::Verifier &verifier)
const {
3314 return VerifyTableStart(verifier) &&
3315 VerifyOffset(verifier,
VT_BASE) &&
3316 verifier.VerifyTable(base()) &&
3318 verifier.VerifyTable(descriptor()) &&
3319 verifier.EndTable();
3325 flatbuffers::FlatBufferBuilder &
fbb_;
3327 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3330 void add_descriptor(flatbuffers::Offset<armnnSerializer::Convolution3dDescriptor> descriptor) {
3335 start_ = fbb_.StartTable();
3338 flatbuffers::Offset<Convolution3dLayer>
Finish() {
3339 const auto end = fbb_.EndTable(start_);
3340 auto o = flatbuffers::Offset<Convolution3dLayer>(end);
3346 flatbuffers::FlatBufferBuilder &_fbb,
3347 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3348 flatbuffers::Offset<armnnSerializer::Convolution3dDescriptor> descriptor = 0) {
3352 return builder_.
Finish();
3355 struct Convolution3dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3357 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3380 return GetField<uint32_t>(
VT_PADTOP, 0);
3415 bool Verify(flatbuffers::Verifier &verifier)
const {
3416 return VerifyTableStart(verifier) &&
3417 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
3419 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
3422 VerifyField<uint32_t>(verifier,
VT_PADBACK) &&
3423 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
3424 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
3425 VerifyField<uint32_t>(verifier,
VT_STRIDEZ) &&
3431 verifier.EndTable();
3437 flatbuffers::FlatBufferBuilder &
fbb_;
3483 start_ = fbb_.StartTable();
3486 flatbuffers::Offset<Convolution3dDescriptor>
Finish() {
3487 const auto end = fbb_.EndTable(start_);
3488 auto o = flatbuffers::Offset<Convolution3dDescriptor>(end);
3494 flatbuffers::FlatBufferBuilder &_fbb,
3495 uint32_t padLeft = 0,
3496 uint32_t padRight = 0,
3497 uint32_t padTop = 0,
3498 uint32_t padBottom = 0,
3499 uint32_t padFront = 0,
3500 uint32_t padBack = 0,
3501 uint32_t strideX = 0,
3502 uint32_t strideY = 0,
3503 uint32_t strideZ = 0,
3504 uint32_t dilationX = 1,
3505 uint32_t dilationY = 1,
3506 uint32_t dilationZ = 1,
3507 bool biasEnabled =
false,
3524 return builder_.
Finish();
3527 struct DepthToSpaceLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3529 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3533 const armnnSerializer::LayerBase *
base()
const {
3534 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3537 return GetPointer<const armnnSerializer::DepthToSpaceDescriptor *>(
VT_DESCRIPTOR);
3539 bool Verify(flatbuffers::Verifier &verifier)
const {
3540 return VerifyTableStart(verifier) &&
3541 VerifyOffset(verifier,
VT_BASE) &&
3542 verifier.VerifyTable(base()) &&
3544 verifier.VerifyTable(descriptor()) &&
3545 verifier.EndTable();
3551 flatbuffers::FlatBufferBuilder &
fbb_;
3553 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3556 void add_descriptor(flatbuffers::Offset<armnnSerializer::DepthToSpaceDescriptor> descriptor) {
3561 start_ = fbb_.StartTable();
3564 flatbuffers::Offset<DepthToSpaceLayer>
Finish() {
3565 const auto end = fbb_.EndTable(start_);
3566 auto o = flatbuffers::Offset<DepthToSpaceLayer>(end);
3572 flatbuffers::FlatBufferBuilder &_fbb,
3573 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3574 flatbuffers::Offset<armnnSerializer::DepthToSpaceDescriptor> descriptor = 0) {
3578 return builder_.
Finish();
3583 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3593 bool Verify(flatbuffers::Verifier &verifier)
const {
3594 return VerifyTableStart(verifier) &&
3597 verifier.EndTable();
3603 flatbuffers::FlatBufferBuilder &
fbb_;
3613 start_ = fbb_.StartTable();
3616 flatbuffers::Offset<DepthToSpaceDescriptor>
Finish() {
3617 const auto end = fbb_.EndTable(start_);
3618 auto o = flatbuffers::Offset<DepthToSpaceDescriptor>(end);
3624 flatbuffers::FlatBufferBuilder &_fbb,
3625 uint32_t blockSize = 0,
3630 return builder_.
Finish();
3633 struct DivisionLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3635 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3638 const armnnSerializer::LayerBase *
base()
const {
3639 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3641 bool Verify(flatbuffers::Verifier &verifier)
const {
3642 return VerifyTableStart(verifier) &&
3643 VerifyOffset(verifier,
VT_BASE) &&
3644 verifier.VerifyTable(base()) &&
3645 verifier.EndTable();
3651 flatbuffers::FlatBufferBuilder &
fbb_;
3653 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3658 start_ = fbb_.StartTable();
3661 flatbuffers::Offset<DivisionLayer>
Finish() {
3662 const auto end = fbb_.EndTable(start_);
3663 auto o = flatbuffers::Offset<DivisionLayer>(end);
3669 flatbuffers::FlatBufferBuilder &_fbb,
3670 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
3673 return builder_.
Finish();
3676 struct ElementwiseUnaryDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3678 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3684 bool Verify(flatbuffers::Verifier &verifier)
const {
3685 return VerifyTableStart(verifier) &&
3686 VerifyField<int8_t>(verifier, VT_OPERATION) &&
3687 verifier.EndTable();
3692 typedef ElementwiseUnaryDescriptor
Table;
3693 flatbuffers::FlatBufferBuilder &
fbb_;
3696 fbb_.AddElement<int8_t>(ElementwiseUnaryDescriptor::VT_OPERATION,
static_cast<int8_t
>(operation), 0);
3700 start_ = fbb_.StartTable();
3703 flatbuffers::Offset<ElementwiseUnaryDescriptor>
Finish() {
3704 const auto end = fbb_.EndTable(start_);
3705 auto o = flatbuffers::Offset<ElementwiseUnaryDescriptor>(end);
3711 flatbuffers::FlatBufferBuilder &_fbb,
3715 return builder_.
Finish();
3718 struct ElementwiseUnaryLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3720 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3724 const armnnSerializer::LayerBase *
base()
const {
3725 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3727 const armnnSerializer::ElementwiseUnaryDescriptor *
descriptor()
const {
3728 return GetPointer<const armnnSerializer::ElementwiseUnaryDescriptor *>(
VT_DESCRIPTOR);
3730 bool Verify(flatbuffers::Verifier &verifier)
const {
3731 return VerifyTableStart(verifier) &&
3732 VerifyOffset(verifier,
VT_BASE) &&
3733 verifier.VerifyTable(base()) &&
3735 verifier.VerifyTable(descriptor()) &&
3736 verifier.EndTable();
3742 flatbuffers::FlatBufferBuilder &
fbb_;
3744 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3747 void add_descriptor(flatbuffers::Offset<armnnSerializer::ElementwiseUnaryDescriptor> descriptor) {
3752 start_ = fbb_.StartTable();
3755 flatbuffers::Offset<ElementwiseUnaryLayer>
Finish() {
3756 const auto end = fbb_.EndTable(start_);
3757 auto o = flatbuffers::Offset<ElementwiseUnaryLayer>(end);
3763 flatbuffers::FlatBufferBuilder &_fbb,
3764 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3765 flatbuffers::Offset<armnnSerializer::ElementwiseUnaryDescriptor> descriptor = 0) {
3769 return builder_.
Finish();
3773 struct EqualLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3775 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3778 const armnnSerializer::LayerBase *
base()
const {
3779 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3781 bool Verify(flatbuffers::Verifier &verifier)
const {
3782 return VerifyTableStart(verifier) &&
3783 VerifyOffset(verifier,
VT_BASE) &&
3784 verifier.VerifyTable(base()) &&
3785 verifier.EndTable();
3791 flatbuffers::FlatBufferBuilder &
fbb_;
3793 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3798 start_ = fbb_.StartTable();
3802 const auto end = fbb_.EndTable(start_);
3803 auto o = flatbuffers::Offset<EqualLayer>(end);
3809 flatbuffers::FlatBufferBuilder &_fbb,
3810 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
3813 return builder_.
Finish();
3816 struct FillLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3818 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3822 const armnnSerializer::LayerBase *
base()
const {
3823 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3826 return GetPointer<const armnnSerializer::FillDescriptor *>(
VT_DESCRIPTOR);
3828 bool Verify(flatbuffers::Verifier &verifier)
const {
3829 return VerifyTableStart(verifier) &&
3830 VerifyOffset(verifier,
VT_BASE) &&
3831 verifier.VerifyTable(base()) &&
3833 verifier.VerifyTable(descriptor()) &&
3834 verifier.EndTable();
3840 flatbuffers::FlatBufferBuilder &
fbb_;
3842 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3845 void add_descriptor(flatbuffers::Offset<armnnSerializer::FillDescriptor> descriptor) {
3850 start_ = fbb_.StartTable();
3854 const auto end = fbb_.EndTable(start_);
3855 auto o = flatbuffers::Offset<FillLayer>(end);
3861 flatbuffers::FlatBufferBuilder &_fbb,
3862 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3863 flatbuffers::Offset<armnnSerializer::FillDescriptor> descriptor = 0) {
3867 return builder_.
Finish();
3870 struct FillDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3872 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3876 return GetField<float>(VT_VALUE, 0.0f);
3878 bool Verify(flatbuffers::Verifier &verifier)
const {
3879 return VerifyTableStart(verifier) &&
3880 VerifyField<float>(verifier, VT_VALUE) &&
3881 verifier.EndTable();
3887 flatbuffers::FlatBufferBuilder &
fbb_;
3890 fbb_.AddElement<
float>(FillDescriptor::VT_VALUE, value, 0.0f);
3894 start_ = fbb_.StartTable();
3897 flatbuffers::Offset<FillDescriptor>
Finish() {
3898 const auto end = fbb_.EndTable(start_);
3899 auto o = flatbuffers::Offset<FillDescriptor>(end);
3905 flatbuffers::FlatBufferBuilder &_fbb,
3906 float value = 0.0f) {
3909 return builder_.
Finish();
3912 struct FloorLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3914 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3917 const armnnSerializer::LayerBase *
base()
const {
3918 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3920 bool Verify(flatbuffers::Verifier &verifier)
const {
3921 return VerifyTableStart(verifier) &&
3922 VerifyOffset(verifier,
VT_BASE) &&
3923 verifier.VerifyTable(base()) &&
3924 verifier.EndTable();
3930 flatbuffers::FlatBufferBuilder &
fbb_;
3932 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3937 start_ = fbb_.StartTable();
3941 const auto end = fbb_.EndTable(start_);
3942 auto o = flatbuffers::Offset<FloorLayer>(end);
3948 flatbuffers::FlatBufferBuilder &_fbb,
3949 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
3952 return builder_.
Finish();
3955 struct FullyConnectedLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3957 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3963 const armnnSerializer::LayerBase *
base()
const {
3964 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3966 const armnnSerializer::FullyConnectedDescriptor *
descriptor()
const {
3967 return GetPointer<const armnnSerializer::FullyConnectedDescriptor *>(
VT_DESCRIPTOR);
3969 const armnnSerializer::ConstTensor *
weights()
const {
3970 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_WEIGHTS);
3972 const armnnSerializer::ConstTensor *
biases()
const {
3973 return GetPointer<const armnnSerializer::ConstTensor *>(VT_BIASES);
3975 bool Verify(flatbuffers::Verifier &verifier)
const {
3976 return VerifyTableStart(verifier) &&
3977 VerifyOffset(verifier,
VT_BASE) &&
3978 verifier.VerifyTable(base()) &&
3980 verifier.VerifyTable(descriptor()) &&
3982 verifier.VerifyTable(weights()) &&
3983 VerifyOffset(verifier, VT_BIASES) &&
3984 verifier.VerifyTable(biases()) &&
3985 verifier.EndTable();
3991 flatbuffers::FlatBufferBuilder &
fbb_;
3993 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3996 void add_descriptor(flatbuffers::Offset<armnnSerializer::FullyConnectedDescriptor> descriptor) {
3999 void add_weights(flatbuffers::Offset<armnnSerializer::ConstTensor> weights) {
4002 void add_biases(flatbuffers::Offset<armnnSerializer::ConstTensor> biases) {
4003 fbb_.AddOffset(FullyConnectedLayer::VT_BIASES, biases);
4007 start_ = fbb_.StartTable();
4010 flatbuffers::Offset<FullyConnectedLayer>
Finish() {
4011 const auto end = fbb_.EndTable(start_);
4012 auto o = flatbuffers::Offset<FullyConnectedLayer>(end);
4018 flatbuffers::FlatBufferBuilder &_fbb,
4019 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4020 flatbuffers::Offset<armnnSerializer::FullyConnectedDescriptor> descriptor = 0,
4021 flatbuffers::Offset<armnnSerializer::ConstTensor> weights = 0,
4022 flatbuffers::Offset<armnnSerializer::ConstTensor> biases = 0) {
4028 return builder_.
Finish();
4031 struct FullyConnectedDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4033 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4036 VT_CONSTANTWEIGHTS = 8
4045 return GetField<uint8_t>(VT_CONSTANTWEIGHTS, 1) != 0;
4047 bool Verify(flatbuffers::Verifier &verifier)
const {
4048 return VerifyTableStart(verifier) &&
4051 VerifyField<uint8_t>(verifier, VT_CONSTANTWEIGHTS) &&
4052 verifier.EndTable();
4058 flatbuffers::FlatBufferBuilder &
fbb_;
4067 fbb_.AddElement<uint8_t>(FullyConnectedDescriptor::VT_CONSTANTWEIGHTS,
static_cast<uint8_t
>(constantWeights), 1);
4071 start_ = fbb_.StartTable();
4074 flatbuffers::Offset<FullyConnectedDescriptor>
Finish() {
4075 const auto end = fbb_.EndTable(start_);
4076 auto o = flatbuffers::Offset<FullyConnectedDescriptor>(end);
4082 flatbuffers::FlatBufferBuilder &_fbb,
4083 bool biasEnabled =
false,
4084 bool transposeWeightsMatrix =
false,
4085 bool constantWeights =
true) {
4090 return builder_.
Finish();
4093 struct GatherLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4095 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4099 const armnnSerializer::LayerBase *
base()
const {
4100 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4103 return GetPointer<const armnnSerializer::GatherDescriptor *>(
VT_DESCRIPTOR);
4105 bool Verify(flatbuffers::Verifier &verifier)
const {
4106 return VerifyTableStart(verifier) &&
4107 VerifyOffset(verifier,
VT_BASE) &&
4108 verifier.VerifyTable(base()) &&
4110 verifier.VerifyTable(descriptor()) &&
4111 verifier.EndTable();
4117 flatbuffers::FlatBufferBuilder &
fbb_;
4119 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4122 void add_descriptor(flatbuffers::Offset<armnnSerializer::GatherDescriptor> descriptor) {
4127 start_ = fbb_.StartTable();
4131 const auto end = fbb_.EndTable(start_);
4132 auto o = flatbuffers::Offset<GatherLayer>(end);
4138 flatbuffers::FlatBufferBuilder &_fbb,
4139 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4140 flatbuffers::Offset<armnnSerializer::GatherDescriptor> descriptor = 0) {
4144 return builder_.
Finish();
4147 struct GatherDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4149 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4153 return GetField<int32_t>(
VT_AXIS, 0);
4155 bool Verify(flatbuffers::Verifier &verifier)
const {
4156 return VerifyTableStart(verifier) &&
4157 VerifyField<int32_t>(verifier,
VT_AXIS) &&
4158 verifier.EndTable();
4164 flatbuffers::FlatBufferBuilder &
fbb_;
4171 start_ = fbb_.StartTable();
4174 flatbuffers::Offset<GatherDescriptor>
Finish() {
4175 const auto end = fbb_.EndTable(start_);
4176 auto o = flatbuffers::Offset<GatherDescriptor>(end);
4182 flatbuffers::FlatBufferBuilder &_fbb,
4186 return builder_.
Finish();
4190 struct GreaterLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4192 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4195 const armnnSerializer::LayerBase *
base()
const {
4196 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4198 bool Verify(flatbuffers::Verifier &verifier)
const {
4199 return VerifyTableStart(verifier) &&
4200 VerifyOffset(verifier,
VT_BASE) &&
4201 verifier.VerifyTable(base()) &&
4202 verifier.EndTable();
4208 flatbuffers::FlatBufferBuilder &
fbb_;
4210 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4215 start_ = fbb_.StartTable();
4219 const auto end = fbb_.EndTable(start_);
4220 auto o = flatbuffers::Offset<GreaterLayer>(end);
4226 flatbuffers::FlatBufferBuilder &_fbb,
4227 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4230 return builder_.
Finish();
4233 struct InputLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4235 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4238 const armnnSerializer::BindableLayerBase *
base()
const {
4239 return GetPointer<const armnnSerializer::BindableLayerBase *>(
VT_BASE);
4241 bool Verify(flatbuffers::Verifier &verifier)
const {
4242 return VerifyTableStart(verifier) &&
4243 VerifyOffset(verifier,
VT_BASE) &&
4244 verifier.VerifyTable(base()) &&
4245 verifier.EndTable();
4251 flatbuffers::FlatBufferBuilder &
fbb_;
4253 void add_base(flatbuffers::Offset<armnnSerializer::BindableLayerBase> base) {
4258 start_ = fbb_.StartTable();
4262 const auto end = fbb_.EndTable(start_);
4263 auto o = flatbuffers::Offset<InputLayer>(end);
4269 flatbuffers::FlatBufferBuilder &_fbb,
4270 flatbuffers::Offset<armnnSerializer::BindableLayerBase> base = 0) {
4273 return builder_.
Finish();
4276 struct InstanceNormalizationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4278 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4282 const armnnSerializer::LayerBase *
base()
const {
4283 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4285 const armnnSerializer::InstanceNormalizationDescriptor *
descriptor()
const {
4286 return GetPointer<const armnnSerializer::InstanceNormalizationDescriptor *>(
VT_DESCRIPTOR);
4288 bool Verify(flatbuffers::Verifier &verifier)
const {
4289 return VerifyTableStart(verifier) &&
4290 VerifyOffset(verifier,
VT_BASE) &&
4291 verifier.VerifyTable(base()) &&
4293 verifier.VerifyTable(descriptor()) &&
4294 verifier.EndTable();
4299 typedef InstanceNormalizationLayer
Table;
4300 flatbuffers::FlatBufferBuilder &
fbb_;
4302 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4305 void add_descriptor(flatbuffers::Offset<armnnSerializer::InstanceNormalizationDescriptor> descriptor) {
4310 start_ = fbb_.StartTable();
4313 flatbuffers::Offset<InstanceNormalizationLayer>
Finish() {
4314 const auto end = fbb_.EndTable(start_);
4315 auto o = flatbuffers::Offset<InstanceNormalizationLayer>(end);
4321 flatbuffers::FlatBufferBuilder &_fbb,
4322 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4323 flatbuffers::Offset<armnnSerializer::InstanceNormalizationDescriptor> descriptor = 0) {
4327 return builder_.
Finish();
4330 struct InstanceNormalizationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4332 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4339 return GetField<float>(
VT_GAMMA, 0.0f);
4342 return GetField<float>(
VT_BETA, 0.0f);
4345 return GetField<float>(
VT_EPS, 0.0f);
4350 bool Verify(flatbuffers::Verifier &verifier)
const {
4351 return VerifyTableStart(verifier) &&
4352 VerifyField<float>(verifier,
VT_GAMMA) &&
4353 VerifyField<float>(verifier,
VT_BETA) &&
4354 VerifyField<float>(verifier,
VT_EPS) &&
4356 verifier.EndTable();
4361 typedef InstanceNormalizationDescriptor
Table;
4362 flatbuffers::FlatBufferBuilder &
fbb_;
4378 start_ = fbb_.StartTable();
4381 flatbuffers::Offset<InstanceNormalizationDescriptor>
Finish() {
4382 const auto end = fbb_.EndTable(start_);
4383 auto o = flatbuffers::Offset<InstanceNormalizationDescriptor>(end);
4389 flatbuffers::FlatBufferBuilder &_fbb,
4399 return builder_.
Finish();
4402 struct LogSoftmaxLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4404 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4408 const armnnSerializer::LayerBase *
base()
const {
4409 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4412 return GetPointer<const armnnSerializer::LogSoftmaxDescriptor *>(
VT_DESCRIPTOR);
4414 bool Verify(flatbuffers::Verifier &verifier)
const {
4415 return VerifyTableStart(verifier) &&
4416 VerifyOffset(verifier,
VT_BASE) &&
4417 verifier.VerifyTable(base()) &&
4419 verifier.VerifyTable(descriptor()) &&
4420 verifier.EndTable();
4426 flatbuffers::FlatBufferBuilder &
fbb_;
4428 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4431 void add_descriptor(flatbuffers::Offset<armnnSerializer::LogSoftmaxDescriptor> descriptor) {
4436 start_ = fbb_.StartTable();
4439 flatbuffers::Offset<LogSoftmaxLayer>
Finish() {
4440 const auto end = fbb_.EndTable(start_);
4441 auto o = flatbuffers::Offset<LogSoftmaxLayer>(end);
4447 flatbuffers::FlatBufferBuilder &_fbb,
4448 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4449 flatbuffers::Offset<armnnSerializer::LogSoftmaxDescriptor> descriptor = 0) {
4453 return builder_.
Finish();
4458 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4463 return GetField<float>(
VT_BETA, 1.0f);
4466 return GetField<int32_t>(
VT_AXIS, -1);
4468 bool Verify(flatbuffers::Verifier &verifier)
const {
4469 return VerifyTableStart(verifier) &&
4470 VerifyField<float>(verifier,
VT_BETA) &&
4471 VerifyField<int32_t>(verifier,
VT_AXIS) &&
4472 verifier.EndTable();
4478 flatbuffers::FlatBufferBuilder &
fbb_;
4488 start_ = fbb_.StartTable();
4491 flatbuffers::Offset<LogSoftmaxDescriptor>
Finish() {
4492 const auto end = fbb_.EndTable(start_);
4493 auto o = flatbuffers::Offset<LogSoftmaxDescriptor>(end);
4499 flatbuffers::FlatBufferBuilder &_fbb,
4501 int32_t axis = -1) {
4505 return builder_.
Finish();
4508 struct L2NormalizationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4510 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4514 const armnnSerializer::LayerBase *
base()
const {
4515 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4517 const armnnSerializer::L2NormalizationDescriptor *
descriptor()
const {
4518 return GetPointer<const armnnSerializer::L2NormalizationDescriptor *>(
VT_DESCRIPTOR);
4520 bool Verify(flatbuffers::Verifier &verifier)
const {
4521 return VerifyTableStart(verifier) &&
4522 VerifyOffset(verifier,
VT_BASE) &&
4523 verifier.VerifyTable(base()) &&
4525 verifier.VerifyTable(descriptor()) &&
4526 verifier.EndTable();
4532 flatbuffers::FlatBufferBuilder &
fbb_;
4534 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4537 void add_descriptor(flatbuffers::Offset<armnnSerializer::L2NormalizationDescriptor> descriptor) {
4542 start_ = fbb_.StartTable();
4545 flatbuffers::Offset<L2NormalizationLayer>
Finish() {
4546 const auto end = fbb_.EndTable(start_);
4547 auto o = flatbuffers::Offset<L2NormalizationLayer>(end);
4553 flatbuffers::FlatBufferBuilder &_fbb,
4554 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4555 flatbuffers::Offset<armnnSerializer::L2NormalizationDescriptor> descriptor = 0) {
4559 return builder_.
Finish();
4562 struct L2NormalizationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4564 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4572 return GetField<float>(
VT_EPS, 1e-12f);
4574 bool Verify(flatbuffers::Verifier &verifier)
const {
4575 return VerifyTableStart(verifier) &&
4577 VerifyField<float>(verifier,
VT_EPS) &&
4578 verifier.EndTable();
4583 typedef L2NormalizationDescriptor
Table;
4584 flatbuffers::FlatBufferBuilder &
fbb_;
4594 start_ = fbb_.StartTable();
4597 flatbuffers::Offset<L2NormalizationDescriptor>
Finish() {
4598 const auto end = fbb_.EndTable(start_);
4599 auto o = flatbuffers::Offset<L2NormalizationDescriptor>(end);
4605 flatbuffers::FlatBufferBuilder &_fbb,
4607 float eps = 1e-12f) {
4611 return builder_.
Finish();
4614 struct LogicalBinaryDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4616 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4622 bool Verify(flatbuffers::Verifier &verifier)
const {
4623 return VerifyTableStart(verifier) &&
4624 VerifyField<int8_t>(verifier, VT_OPERATION) &&
4625 verifier.EndTable();
4631 flatbuffers::FlatBufferBuilder &
fbb_;
4634 fbb_.AddElement<int8_t>(LogicalBinaryDescriptor::VT_OPERATION,
static_cast<int8_t
>(operation), 0);
4638 start_ = fbb_.StartTable();
4641 flatbuffers::Offset<LogicalBinaryDescriptor>
Finish() {
4642 const auto end = fbb_.EndTable(start_);
4643 auto o = flatbuffers::Offset<LogicalBinaryDescriptor>(end);
4649 flatbuffers::FlatBufferBuilder &_fbb,
4653 return builder_.
Finish();
4656 struct LogicalBinaryLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4658 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4662 const armnnSerializer::LayerBase *
base()
const {
4663 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4665 const armnnSerializer::LogicalBinaryDescriptor *
descriptor()
const {
4666 return GetPointer<const armnnSerializer::LogicalBinaryDescriptor *>(
VT_DESCRIPTOR);
4668 bool Verify(flatbuffers::Verifier &verifier)
const {
4669 return VerifyTableStart(verifier) &&
4670 VerifyOffset(verifier,
VT_BASE) &&
4671 verifier.VerifyTable(base()) &&
4673 verifier.VerifyTable(descriptor()) &&
4674 verifier.EndTable();
4680 flatbuffers::FlatBufferBuilder &
fbb_;
4682 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4685 void add_descriptor(flatbuffers::Offset<armnnSerializer::LogicalBinaryDescriptor> descriptor) {
4690 start_ = fbb_.StartTable();
4693 flatbuffers::Offset<LogicalBinaryLayer>
Finish() {
4694 const auto end = fbb_.EndTable(start_);
4695 auto o = flatbuffers::Offset<LogicalBinaryLayer>(end);
4701 flatbuffers::FlatBufferBuilder &_fbb,
4702 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4703 flatbuffers::Offset<armnnSerializer::LogicalBinaryDescriptor> descriptor = 0) {
4707 return builder_.
Finish();
4710 struct MinimumLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4712 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4715 const armnnSerializer::LayerBase *
base()
const {
4716 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4718 bool Verify(flatbuffers::Verifier &verifier)
const {
4719 return VerifyTableStart(verifier) &&
4720 VerifyOffset(verifier,
VT_BASE) &&
4721 verifier.VerifyTable(base()) &&
4722 verifier.EndTable();
4728 flatbuffers::FlatBufferBuilder &
fbb_;
4730 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4735 start_ = fbb_.StartTable();
4739 const auto end = fbb_.EndTable(start_);
4740 auto o = flatbuffers::Offset<MinimumLayer>(end);
4746 flatbuffers::FlatBufferBuilder &_fbb,
4747 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4750 return builder_.
Finish();
4753 struct MaximumLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4755 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4758 const armnnSerializer::LayerBase *
base()
const {
4759 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4761 bool Verify(flatbuffers::Verifier &verifier)
const {
4762 return VerifyTableStart(verifier) &&
4763 VerifyOffset(verifier,
VT_BASE) &&
4764 verifier.VerifyTable(base()) &&
4765 verifier.EndTable();
4771 flatbuffers::FlatBufferBuilder &
fbb_;
4773 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4778 start_ = fbb_.StartTable();
4782 const auto end = fbb_.EndTable(start_);
4783 auto o = flatbuffers::Offset<MaximumLayer>(end);
4789 flatbuffers::FlatBufferBuilder &_fbb,
4790 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4793 return builder_.
Finish();
4796 struct MultiplicationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4798 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4801 const armnnSerializer::LayerBase *
base()
const {
4802 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4804 bool Verify(flatbuffers::Verifier &verifier)
const {
4805 return VerifyTableStart(verifier) &&
4806 VerifyOffset(verifier,
VT_BASE) &&
4807 verifier.VerifyTable(base()) &&
4808 verifier.EndTable();
4814 flatbuffers::FlatBufferBuilder &
fbb_;
4816 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4821 start_ = fbb_.StartTable();
4824 flatbuffers::Offset<MultiplicationLayer>
Finish() {
4825 const auto end = fbb_.EndTable(start_);
4826 auto o = flatbuffers::Offset<MultiplicationLayer>(end);
4832 flatbuffers::FlatBufferBuilder &_fbb,
4833 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4836 return builder_.
Finish();
4839 struct Pooling2dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4841 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4845 const armnnSerializer::LayerBase *
base()
const {
4846 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4849 return GetPointer<const armnnSerializer::Pooling2dDescriptor *>(
VT_DESCRIPTOR);
4851 bool Verify(flatbuffers::Verifier &verifier)
const {
4852 return VerifyTableStart(verifier) &&
4853 VerifyOffset(verifier,
VT_BASE) &&
4854 verifier.VerifyTable(base()) &&
4856 verifier.VerifyTable(descriptor()) &&
4857 verifier.EndTable();
4863 flatbuffers::FlatBufferBuilder &
fbb_;
4865 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4868 void add_descriptor(flatbuffers::Offset<armnnSerializer::Pooling2dDescriptor> descriptor) {
4873 start_ = fbb_.StartTable();
4876 flatbuffers::Offset<Pooling2dLayer>
Finish() {
4877 const auto end = fbb_.EndTable(start_);
4878 auto o = flatbuffers::Offset<Pooling2dLayer>(end);
4884 flatbuffers::FlatBufferBuilder &_fbb,
4885 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4886 flatbuffers::Offset<armnnSerializer::Pooling2dDescriptor> descriptor = 0) {
4890 return builder_.
Finish();
4893 struct Pooling3dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4895 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4899 const armnnSerializer::LayerBase *
base()
const {
4900 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4903 return GetPointer<const armnnSerializer::Pooling3dDescriptor *>(
VT_DESCRIPTOR);
4905 bool Verify(flatbuffers::Verifier &verifier)
const {
4906 return VerifyTableStart(verifier) &&
4907 VerifyOffset(verifier,
VT_BASE) &&
4908 verifier.VerifyTable(base()) &&
4910 verifier.VerifyTable(descriptor()) &&
4911 verifier.EndTable();
4917 flatbuffers::FlatBufferBuilder &
fbb_;
4919 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4922 void add_descriptor(flatbuffers::Offset<armnnSerializer::Pooling3dDescriptor> descriptor) {
4927 start_ = fbb_.StartTable();
4930 flatbuffers::Offset<Pooling3dLayer>
Finish() {
4931 const auto end = fbb_.EndTable(start_);
4932 auto o = flatbuffers::Offset<Pooling3dLayer>(end);
4938 flatbuffers::FlatBufferBuilder &_fbb,
4939 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4940 flatbuffers::Offset<armnnSerializer::Pooling3dDescriptor> descriptor = 0) {
4944 return builder_.
Finish();
4949 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4973 return GetField<uint32_t>(
VT_PADTOP, 0);
4999 bool Verify(flatbuffers::Verifier &verifier)
const {
5000 return VerifyTableStart(verifier) &&
5002 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
5004 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
5008 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
5009 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
5013 verifier.EndTable();
5019 flatbuffers::FlatBufferBuilder &
fbb_;
5059 start_ = fbb_.StartTable();
5062 flatbuffers::Offset<Pooling2dDescriptor>
Finish() {
5063 const auto end = fbb_.EndTable(start_);
5064 auto o = flatbuffers::Offset<Pooling2dDescriptor>(end);
5070 flatbuffers::FlatBufferBuilder &_fbb,
5072 uint32_t padLeft = 0,
5073 uint32_t padRight = 0,
5074 uint32_t padTop = 0,
5075 uint32_t padBottom = 0,
5076 uint32_t poolWidth = 0,
5077 uint32_t poolHeight = 0,
5078 uint32_t strideX = 0,
5079 uint32_t strideY = 0,
5096 return builder_.
Finish();
5101 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5129 return GetField<uint32_t>(
VT_PADTOP, 0);
5167 bool Verify(flatbuffers::Verifier &verifier)
const {
5168 return VerifyTableStart(verifier) &&
5170 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
5172 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
5175 VerifyField<uint32_t>(verifier,
VT_PADBACK) &&
5179 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
5180 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
5181 VerifyField<uint32_t>(verifier,
VT_STRIDEZ) &&
5185 verifier.EndTable();
5191 flatbuffers::FlatBufferBuilder &
fbb_;
5243 start_ = fbb_.StartTable();
5246 flatbuffers::Offset<Pooling3dDescriptor>
Finish() {
5247 const auto end = fbb_.EndTable(start_);
5248 auto o = flatbuffers::Offset<Pooling3dDescriptor>(end);
5254 flatbuffers::FlatBufferBuilder &_fbb,
5256 uint32_t padLeft = 0,
5257 uint32_t padRight = 0,
5258 uint32_t padTop = 0,
5259 uint32_t padBottom = 0,
5260 uint32_t padFront = 0,
5261 uint32_t padBack = 0,
5262 uint32_t poolWidth = 0,
5263 uint32_t poolHeight = 0,
5264 uint32_t poolDepth = 0,
5265 uint32_t strideX = 0,
5266 uint32_t strideY = 0,
5267 uint32_t strideZ = 0,
5288 return builder_.
Finish();
5291 struct QuantizeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5293 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5296 const armnnSerializer::LayerBase *
base()
const {
5297 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5299 bool Verify(flatbuffers::Verifier &verifier)
const {
5300 return VerifyTableStart(verifier) &&
5301 VerifyOffset(verifier,
VT_BASE) &&
5302 verifier.VerifyTable(base()) &&
5303 verifier.EndTable();
5309 flatbuffers::FlatBufferBuilder &
fbb_;
5311 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5316 start_ = fbb_.StartTable();
5319 flatbuffers::Offset<QuantizeLayer>
Finish() {
5320 const auto end = fbb_.EndTable(start_);
5321 auto o = flatbuffers::Offset<QuantizeLayer>(end);
5327 flatbuffers::FlatBufferBuilder &_fbb,
5328 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
5331 return builder_.
Finish();
5334 struct SoftmaxLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5336 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5340 const armnnSerializer::LayerBase *
base()
const {
5341 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5344 return GetPointer<const armnnSerializer::SoftmaxDescriptor *>(
VT_DESCRIPTOR);
5346 bool Verify(flatbuffers::Verifier &verifier)
const {
5347 return VerifyTableStart(verifier) &&
5348 VerifyOffset(verifier,
VT_BASE) &&
5349 verifier.VerifyTable(base()) &&
5351 verifier.VerifyTable(descriptor()) &&
5352 verifier.EndTable();
5358 flatbuffers::FlatBufferBuilder &
fbb_;
5360 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5363 void add_descriptor(flatbuffers::Offset<armnnSerializer::SoftmaxDescriptor> descriptor) {
5368 start_ = fbb_.StartTable();
5372 const auto end = fbb_.EndTable(start_);
5373 auto o = flatbuffers::Offset<SoftmaxLayer>(end);
5379 flatbuffers::FlatBufferBuilder &_fbb,
5380 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5381 flatbuffers::Offset<armnnSerializer::SoftmaxDescriptor> descriptor = 0) {
5385 return builder_.
Finish();
5388 struct SoftmaxDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5390 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5395 return GetField<float>(
VT_BETA, 0.0f);
5398 return GetField<int32_t>(
VT_AXIS, -1);
5400 bool Verify(flatbuffers::Verifier &verifier)
const {
5401 return VerifyTableStart(verifier) &&
5402 VerifyField<float>(verifier,
VT_BETA) &&
5403 VerifyField<int32_t>(verifier,
VT_AXIS) &&
5404 verifier.EndTable();
5410 flatbuffers::FlatBufferBuilder &
fbb_;
5420 start_ = fbb_.StartTable();
5423 flatbuffers::Offset<SoftmaxDescriptor>
Finish() {
5424 const auto end = fbb_.EndTable(start_);
5425 auto o = flatbuffers::Offset<SoftmaxDescriptor>(end);
5431 flatbuffers::FlatBufferBuilder &_fbb,
5433 int32_t axis = -1) {
5437 return builder_.
Finish();
5440 struct DepthwiseConvolution2dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5442 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5448 const armnnSerializer::LayerBase *
base()
const {
5449 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5451 const armnnSerializer::DepthwiseConvolution2dDescriptor *
descriptor()
const {
5452 return GetPointer<const armnnSerializer::DepthwiseConvolution2dDescriptor *>(
VT_DESCRIPTOR);
5454 const armnnSerializer::ConstTensor *
weights()
const {
5455 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_WEIGHTS);
5457 const armnnSerializer::ConstTensor *
biases()
const {
5458 return GetPointer<const armnnSerializer::ConstTensor *>(VT_BIASES);
5460 bool Verify(flatbuffers::Verifier &verifier)
const {
5461 return VerifyTableStart(verifier) &&
5462 VerifyOffset(verifier,
VT_BASE) &&
5463 verifier.VerifyTable(base()) &&
5465 verifier.VerifyTable(descriptor()) &&
5467 verifier.VerifyTable(weights()) &&
5468 VerifyOffset(verifier, VT_BIASES) &&
5469 verifier.VerifyTable(biases()) &&
5470 verifier.EndTable();
5475 typedef DepthwiseConvolution2dLayer
Table;
5476 flatbuffers::FlatBufferBuilder &
fbb_;
5478 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5481 void add_descriptor(flatbuffers::Offset<armnnSerializer::DepthwiseConvolution2dDescriptor> descriptor) {
5484 void add_weights(flatbuffers::Offset<armnnSerializer::ConstTensor> weights) {
5487 void add_biases(flatbuffers::Offset<armnnSerializer::ConstTensor> biases) {
5488 fbb_.AddOffset(DepthwiseConvolution2dLayer::VT_BIASES, biases);
5492 start_ = fbb_.StartTable();
5495 flatbuffers::Offset<DepthwiseConvolution2dLayer>
Finish() {
5496 const auto end = fbb_.EndTable(start_);
5497 auto o = flatbuffers::Offset<DepthwiseConvolution2dLayer>(end);
5503 flatbuffers::FlatBufferBuilder &_fbb,
5504 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5505 flatbuffers::Offset<armnnSerializer::DepthwiseConvolution2dDescriptor> descriptor = 0,
5506 flatbuffers::Offset<armnnSerializer::ConstTensor> weights = 0,
5507 flatbuffers::Offset<armnnSerializer::ConstTensor> biases = 0) {
5513 return builder_.
Finish();
5516 struct DepthwiseConvolution2dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5518 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5537 return GetField<uint32_t>(
VT_PADTOP, 0);
5560 bool Verify(flatbuffers::Verifier &verifier)
const {
5561 return VerifyTableStart(verifier) &&
5562 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
5564 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
5566 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
5567 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
5572 verifier.EndTable();
5577 typedef DepthwiseConvolution2dDescriptor
Table;
5578 flatbuffers::FlatBufferBuilder &
fbb_;
5612 start_ = fbb_.StartTable();
5615 flatbuffers::Offset<DepthwiseConvolution2dDescriptor>
Finish() {
5616 const auto end = fbb_.EndTable(start_);
5617 auto o = flatbuffers::Offset<DepthwiseConvolution2dDescriptor>(end);
5623 flatbuffers::FlatBufferBuilder &_fbb,
5624 uint32_t padLeft = 0,
5625 uint32_t padRight = 0,
5626 uint32_t padTop = 0,
5627 uint32_t padBottom = 0,
5628 uint32_t strideX = 0,
5629 uint32_t strideY = 0,
5630 uint32_t dilationX = 1,
5631 uint32_t dilationY = 1,
5632 bool biasEnabled =
false,
5645 return builder_.
Finish();
5648 struct OutputLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5650 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5653 const armnnSerializer::BindableLayerBase *
base()
const {
5654 return GetPointer<const armnnSerializer::BindableLayerBase *>(
VT_BASE);
5656 bool Verify(flatbuffers::Verifier &verifier)
const {
5657 return VerifyTableStart(verifier) &&
5658 VerifyOffset(verifier,
VT_BASE) &&
5659 verifier.VerifyTable(base()) &&
5660 verifier.EndTable();
5666 flatbuffers::FlatBufferBuilder &
fbb_;
5668 void add_base(flatbuffers::Offset<armnnSerializer::BindableLayerBase> base) {
5673 start_ = fbb_.StartTable();
5677 const auto end = fbb_.EndTable(start_);
5678 auto o = flatbuffers::Offset<OutputLayer>(end);
5684 flatbuffers::FlatBufferBuilder &_fbb,
5685 flatbuffers::Offset<armnnSerializer::BindableLayerBase> base = 0) {
5688 return builder_.
Finish();
5691 struct ReshapeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5693 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5697 const armnnSerializer::LayerBase *
base()
const {
5698 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5701 return GetPointer<const armnnSerializer::ReshapeDescriptor *>(
VT_DESCRIPTOR);
5703 bool Verify(flatbuffers::Verifier &verifier)
const {
5704 return VerifyTableStart(verifier) &&
5705 VerifyOffset(verifier,
VT_BASE) &&
5706 verifier.VerifyTable(base()) &&
5708 verifier.VerifyTable(descriptor()) &&
5709 verifier.EndTable();
5715 flatbuffers::FlatBufferBuilder &
fbb_;
5717 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5720 void add_descriptor(flatbuffers::Offset<armnnSerializer::ReshapeDescriptor> descriptor) {
5725 start_ = fbb_.StartTable();
5729 const auto end = fbb_.EndTable(start_);
5730 auto o = flatbuffers::Offset<ReshapeLayer>(end);
5736 flatbuffers::FlatBufferBuilder &_fbb,
5737 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5738 flatbuffers::Offset<armnnSerializer::ReshapeDescriptor> descriptor = 0) {
5742 return builder_.
Finish();
5745 struct ReshapeDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5747 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5751 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_TARGETSHAPE);
5753 bool Verify(flatbuffers::Verifier &verifier)
const {
5754 return VerifyTableStart(verifier) &&
5755 VerifyOffset(verifier, VT_TARGETSHAPE) &&
5756 verifier.VerifyVector(targetShape()) &&
5757 verifier.EndTable();
5763 flatbuffers::FlatBufferBuilder &
fbb_;
5766 fbb_.AddOffset(ReshapeDescriptor::VT_TARGETSHAPE, targetShape);
5770 start_ = fbb_.StartTable();
5773 flatbuffers::Offset<ReshapeDescriptor>
Finish() {
5774 const auto end = fbb_.EndTable(start_);
5775 auto o = flatbuffers::Offset<ReshapeDescriptor>(end);
5781 flatbuffers::FlatBufferBuilder &_fbb,
5785 return builder_.
Finish();
5789 flatbuffers::FlatBufferBuilder &_fbb,
5790 const std::vector<uint32_t> *targetShape =
nullptr) {
5791 auto targetShape__ = targetShape ? _fbb.CreateVector<uint32_t>(*targetShape) : 0;
5797 struct PermuteLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5799 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5803 const armnnSerializer::LayerBase *
base()
const {
5804 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5807 return GetPointer<const armnnSerializer::PermuteDescriptor *>(
VT_DESCRIPTOR);
5809 bool Verify(flatbuffers::Verifier &verifier)
const {
5810 return VerifyTableStart(verifier) &&
5811 VerifyOffset(verifier,
VT_BASE) &&
5812 verifier.VerifyTable(base()) &&
5814 verifier.VerifyTable(descriptor()) &&
5815 verifier.EndTable();
5821 flatbuffers::FlatBufferBuilder &
fbb_;
5823 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5826 void add_descriptor(flatbuffers::Offset<armnnSerializer::PermuteDescriptor> descriptor) {
5831 start_ = fbb_.StartTable();
5835 const auto end = fbb_.EndTable(start_);
5836 auto o = flatbuffers::Offset<PermuteLayer>(end);
5842 flatbuffers::FlatBufferBuilder &_fbb,
5843 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5844 flatbuffers::Offset<armnnSerializer::PermuteDescriptor> descriptor = 0) {
5848 return builder_.
Finish();
5851 struct PermuteDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5853 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5857 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DIMMAPPINGS);
5859 bool Verify(flatbuffers::Verifier &verifier)
const {
5860 return VerifyTableStart(verifier) &&
5861 VerifyOffset(verifier, VT_DIMMAPPINGS) &&
5862 verifier.VerifyVector(dimMappings()) &&
5863 verifier.EndTable();
5869 flatbuffers::FlatBufferBuilder &
fbb_;
5872 fbb_.AddOffset(PermuteDescriptor::VT_DIMMAPPINGS, dimMappings);
5876 start_ = fbb_.StartTable();
5879 flatbuffers::Offset<PermuteDescriptor>
Finish() {
5880 const auto end = fbb_.EndTable(start_);
5881 auto o = flatbuffers::Offset<PermuteDescriptor>(end);
5887 flatbuffers::FlatBufferBuilder &_fbb,
5891 return builder_.
Finish();
5895 flatbuffers::FlatBufferBuilder &_fbb,
5896 const std::vector<uint32_t> *dimMappings =
nullptr) {
5897 auto dimMappings__ = dimMappings ? _fbb.CreateVector<uint32_t>(*dimMappings) : 0;
5903 struct ShapeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5905 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5908 const armnnSerializer::LayerBase *
base()
const {
5909 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5911 bool Verify(flatbuffers::Verifier &verifier)
const {
5912 return VerifyTableStart(verifier) &&
5913 VerifyOffset(verifier,
VT_BASE) &&
5914 verifier.VerifyTable(base()) &&
5915 verifier.EndTable();
5921 flatbuffers::FlatBufferBuilder &
fbb_;
5923 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5928 start_ = fbb_.StartTable();
5932 const auto end = fbb_.EndTable(start_);
5933 auto o = flatbuffers::Offset<ShapeLayer>(end);
5939 flatbuffers::FlatBufferBuilder &_fbb,
5940 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
5943 return builder_.
Finish();
5946 struct SpaceToBatchNdLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5948 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5952 const armnnSerializer::LayerBase *
base()
const {
5953 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5955 const armnnSerializer::SpaceToBatchNdDescriptor *
descriptor()
const {
5956 return GetPointer<const armnnSerializer::SpaceToBatchNdDescriptor *>(
VT_DESCRIPTOR);
5958 bool Verify(flatbuffers::Verifier &verifier)
const {
5959 return VerifyTableStart(verifier) &&
5960 VerifyOffset(verifier,
VT_BASE) &&
5961 verifier.VerifyTable(base()) &&
5963 verifier.VerifyTable(descriptor()) &&
5964 verifier.EndTable();
5970 flatbuffers::FlatBufferBuilder &
fbb_;
5972 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5975 void add_descriptor(flatbuffers::Offset<armnnSerializer::SpaceToBatchNdDescriptor> descriptor) {
5980 start_ = fbb_.StartTable();
5983 flatbuffers::Offset<SpaceToBatchNdLayer>
Finish() {
5984 const auto end = fbb_.EndTable(start_);
5985 auto o = flatbuffers::Offset<SpaceToBatchNdLayer>(end);
5991 flatbuffers::FlatBufferBuilder &_fbb,
5992 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5993 flatbuffers::Offset<armnnSerializer::SpaceToBatchNdDescriptor> descriptor = 0) {
5997 return builder_.
Finish();
6000 struct SpaceToBatchNdDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6002 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6008 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_BLOCKSHAPE);
6010 const flatbuffers::Vector<uint32_t> *
padList()
const {
6011 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_PADLIST);
6016 bool Verify(flatbuffers::Verifier &verifier)
const {
6017 return VerifyTableStart(verifier) &&
6019 verifier.VerifyVector(blockShape()) &&
6021 verifier.VerifyVector(padList()) &&
6023 verifier.EndTable();
6029 flatbuffers::FlatBufferBuilder &
fbb_;
6042 start_ = fbb_.StartTable();
6045 flatbuffers::Offset<SpaceToBatchNdDescriptor>
Finish() {
6046 const auto end = fbb_.EndTable(start_);
6047 auto o = flatbuffers::Offset<SpaceToBatchNdDescriptor>(end);
6053 flatbuffers::FlatBufferBuilder &_fbb,
6061 return builder_.
Finish();
6065 flatbuffers::FlatBufferBuilder &_fbb,
6066 const std::vector<uint32_t> *blockShape =
nullptr,
6067 const std::vector<uint32_t> *padList =
nullptr,
6069 auto blockShape__ = blockShape ? _fbb.CreateVector<uint32_t>(*blockShape) : 0;
6070 auto padList__ = padList ? _fbb.CreateVector<uint32_t>(*padList) : 0;
6078 struct SpaceToDepthLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6080 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6084 const armnnSerializer::LayerBase *
base()
const {
6085 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6087 const armnnSerializer::SpaceToDepthDescriptor *
descriptor()
const {
6088 return GetPointer<const armnnSerializer::SpaceToDepthDescriptor *>(
VT_DESCRIPTOR);
6090 bool Verify(flatbuffers::Verifier &verifier)
const {
6091 return VerifyTableStart(verifier) &&
6092 VerifyOffset(verifier,
VT_BASE) &&
6093 verifier.VerifyTable(base()) &&
6095 verifier.VerifyTable(descriptor()) &&
6096 verifier.EndTable();
6102 flatbuffers::FlatBufferBuilder &
fbb_;
6104 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6107 void add_descriptor(flatbuffers::Offset<armnnSerializer::SpaceToDepthDescriptor> descriptor) {
6112 start_ = fbb_.StartTable();
6115 flatbuffers::Offset<SpaceToDepthLayer>
Finish() {
6116 const auto end = fbb_.EndTable(start_);
6117 auto o = flatbuffers::Offset<SpaceToDepthLayer>(end);
6123 flatbuffers::FlatBufferBuilder &_fbb,
6124 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6125 flatbuffers::Offset<armnnSerializer::SpaceToDepthDescriptor> descriptor = 0) {
6129 return builder_.
Finish();
6132 struct SpaceToDepthDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6134 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6144 bool Verify(flatbuffers::Verifier &verifier)
const {
6145 return VerifyTableStart(verifier) &&
6148 verifier.EndTable();
6154 flatbuffers::FlatBufferBuilder &
fbb_;
6164 start_ = fbb_.StartTable();
6167 flatbuffers::Offset<SpaceToDepthDescriptor>
Finish() {
6168 const auto end = fbb_.EndTable(start_);
6169 auto o = flatbuffers::Offset<SpaceToDepthDescriptor>(end);
6175 flatbuffers::FlatBufferBuilder &_fbb,
6176 uint32_t blockSize = 0,
6181 return builder_.
Finish();
6184 struct SubtractionLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6186 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6189 const armnnSerializer::LayerBase *
base()
const {
6190 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6192 bool Verify(flatbuffers::Verifier &verifier)
const {
6193 return VerifyTableStart(verifier) &&
6194 VerifyOffset(verifier,
VT_BASE) &&
6195 verifier.VerifyTable(base()) &&
6196 verifier.EndTable();
6202 flatbuffers::FlatBufferBuilder &
fbb_;
6204 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6209 start_ = fbb_.StartTable();
6212 flatbuffers::Offset<SubtractionLayer>
Finish() {
6213 const auto end = fbb_.EndTable(start_);
6214 auto o = flatbuffers::Offset<SubtractionLayer>(end);
6220 flatbuffers::FlatBufferBuilder &_fbb,
6221 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
6224 return builder_.
Finish();
6227 struct BatchToSpaceNdLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6229 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6233 const armnnSerializer::LayerBase *
base()
const {
6234 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6236 const armnnSerializer::BatchToSpaceNdDescriptor *
descriptor()
const {
6237 return GetPointer<const armnnSerializer::BatchToSpaceNdDescriptor *>(
VT_DESCRIPTOR);
6239 bool Verify(flatbuffers::Verifier &verifier)
const {
6240 return VerifyTableStart(verifier) &&
6241 VerifyOffset(verifier,
VT_BASE) &&
6242 verifier.VerifyTable(base()) &&
6244 verifier.VerifyTable(descriptor()) &&
6245 verifier.EndTable();
6251 flatbuffers::FlatBufferBuilder &
fbb_;
6253 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6256 void add_descriptor(flatbuffers::Offset<armnnSerializer::BatchToSpaceNdDescriptor> descriptor) {
6261 start_ = fbb_.StartTable();
6264 flatbuffers::Offset<BatchToSpaceNdLayer>
Finish() {
6265 const auto end = fbb_.EndTable(start_);
6266 auto o = flatbuffers::Offset<BatchToSpaceNdLayer>(end);
6272 flatbuffers::FlatBufferBuilder &_fbb,
6273 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6274 flatbuffers::Offset<armnnSerializer::BatchToSpaceNdDescriptor> descriptor = 0) {
6278 return builder_.
Finish();
6281 struct BatchToSpaceNdDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6283 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6289 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_BLOCKSHAPE);
6291 const flatbuffers::Vector<uint32_t> *
crops()
const {
6292 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_CROPS);
6297 bool Verify(flatbuffers::Verifier &verifier)
const {
6298 return VerifyTableStart(verifier) &&
6300 verifier.VerifyVector(blockShape()) &&
6301 VerifyOffset(verifier,
VT_CROPS) &&
6302 verifier.VerifyVector(crops()) &&
6304 verifier.EndTable();
6310 flatbuffers::FlatBufferBuilder &
fbb_;
6323 start_ = fbb_.StartTable();
6326 flatbuffers::Offset<BatchToSpaceNdDescriptor>
Finish() {
6327 const auto end = fbb_.EndTable(start_);
6328 auto o = flatbuffers::Offset<BatchToSpaceNdDescriptor>(end);
6334 flatbuffers::FlatBufferBuilder &_fbb,
6342 return builder_.
Finish();
6346 flatbuffers::FlatBufferBuilder &_fbb,
6347 const std::vector<uint32_t> *blockShape =
nullptr,
6348 const std::vector<uint32_t> *crops =
nullptr,
6350 auto blockShape__ = blockShape ? _fbb.CreateVector<uint32_t>(*blockShape) : 0;
6351 auto crops__ = crops ? _fbb.CreateVector<uint32_t>(*crops) : 0;
6359 struct NormalizationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6361 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6365 const armnnSerializer::LayerBase *
base()
const {
6366 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6368 const armnnSerializer::NormalizationDescriptor *
descriptor()
const {
6369 return GetPointer<const armnnSerializer::NormalizationDescriptor *>(
VT_DESCRIPTOR);
6371 bool Verify(flatbuffers::Verifier &verifier)
const {
6372 return VerifyTableStart(verifier) &&
6373 VerifyOffset(verifier,
VT_BASE) &&
6374 verifier.VerifyTable(base()) &&
6376 verifier.VerifyTable(descriptor()) &&
6377 verifier.EndTable();
6383 flatbuffers::FlatBufferBuilder &
fbb_;
6385 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6388 void add_descriptor(flatbuffers::Offset<armnnSerializer::NormalizationDescriptor> descriptor) {
6393 start_ = fbb_.StartTable();
6396 flatbuffers::Offset<NormalizationLayer>
Finish() {
6397 const auto end = fbb_.EndTable(start_);
6398 auto o = flatbuffers::Offset<NormalizationLayer>(end);
6404 flatbuffers::FlatBufferBuilder &_fbb,
6405 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6406 flatbuffers::Offset<armnnSerializer::NormalizationDescriptor> descriptor = 0) {
6410 return builder_.
Finish();
6413 struct NormalizationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6415 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6434 return GetField<float>(
VT_ALPHA, 0.0f);
6437 return GetField<float>(
VT_BETA, 0.0f);
6440 return GetField<float>(
VT_K, 0.0f);
6445 bool Verify(flatbuffers::Verifier &verifier)
const {
6446 return VerifyTableStart(verifier) &&
6450 VerifyField<float>(verifier,
VT_ALPHA) &&
6451 VerifyField<float>(verifier,
VT_BETA) &&
6452 VerifyField<float>(verifier,
VT_K) &&
6454 verifier.EndTable();
6460 flatbuffers::FlatBufferBuilder &
fbb_;
6485 start_ = fbb_.StartTable();
6488 flatbuffers::Offset<NormalizationDescriptor>
Finish() {
6489 const auto end = fbb_.EndTable(start_);
6490 auto o = flatbuffers::Offset<NormalizationDescriptor>(end);
6496 flatbuffers::FlatBufferBuilder &_fbb,
6499 uint32_t normSize = 0,
6512 return builder_.
Finish();
6515 struct MeanLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6517 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6521 const armnnSerializer::LayerBase *
base()
const {
6522 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6525 return GetPointer<const armnnSerializer::MeanDescriptor *>(
VT_DESCRIPTOR);
6527 bool Verify(flatbuffers::Verifier &verifier)
const {
6528 return VerifyTableStart(verifier) &&
6529 VerifyOffset(verifier,
VT_BASE) &&
6530 verifier.VerifyTable(base()) &&
6532 verifier.VerifyTable(descriptor()) &&
6533 verifier.EndTable();
6539 flatbuffers::FlatBufferBuilder &
fbb_;
6541 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6544 void add_descriptor(flatbuffers::Offset<armnnSerializer::MeanDescriptor> descriptor) {
6549 start_ = fbb_.StartTable();
6553 const auto end = fbb_.EndTable(start_);
6554 auto o = flatbuffers::Offset<MeanLayer>(end);
6560 flatbuffers::FlatBufferBuilder &_fbb,
6561 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6562 flatbuffers::Offset<armnnSerializer::MeanDescriptor> descriptor = 0) {
6566 return builder_.
Finish();
6569 struct MeanDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6571 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6575 const flatbuffers::Vector<uint32_t> *
axis()
const {
6576 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_AXIS);
6581 bool Verify(flatbuffers::Verifier &verifier)
const {
6582 return VerifyTableStart(verifier) &&
6583 VerifyOffset(verifier,
VT_AXIS) &&
6584 verifier.VerifyVector(axis()) &&
6586 verifier.EndTable();
6592 flatbuffers::FlatBufferBuilder &
fbb_;
6602 start_ = fbb_.StartTable();
6605 flatbuffers::Offset<MeanDescriptor>
Finish() {
6606 const auto end = fbb_.EndTable(start_);
6607 auto o = flatbuffers::Offset<MeanDescriptor>(end);
6613 flatbuffers::FlatBufferBuilder &_fbb,
6615 bool keepDims =
false) {
6619 return builder_.
Finish();
6623 flatbuffers::FlatBufferBuilder &_fbb,
6624 const std::vector<uint32_t> *axis =
nullptr,
6625 bool keepDims =
false) {
6626 auto axis__ = axis ? _fbb.CreateVector<uint32_t>(*axis) : 0;
6633 struct PadLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6635 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6639 const armnnSerializer::LayerBase *
base()
const {
6640 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6643 return GetPointer<const armnnSerializer::PadDescriptor *>(
VT_DESCRIPTOR);
6645 bool Verify(flatbuffers::Verifier &verifier)
const {
6646 return VerifyTableStart(verifier) &&
6647 VerifyOffset(verifier,
VT_BASE) &&
6648 verifier.VerifyTable(base()) &&
6650 verifier.VerifyTable(descriptor()) &&
6651 verifier.EndTable();
6657 flatbuffers::FlatBufferBuilder &
fbb_;
6659 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6662 void add_descriptor(flatbuffers::Offset<armnnSerializer::PadDescriptor> descriptor) {
6667 start_ = fbb_.StartTable();
6671 const auto end = fbb_.EndTable(start_);
6672 auto o = flatbuffers::Offset<PadLayer>(end);
6678 flatbuffers::FlatBufferBuilder &_fbb,
6679 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6680 flatbuffers::Offset<armnnSerializer::PadDescriptor> descriptor = 0) {
6684 return builder_.
Finish();
6687 struct PadDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6689 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6694 const flatbuffers::Vector<uint32_t> *
padList()
const {
6695 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_PADLIST);
6703 bool Verify(flatbuffers::Verifier &verifier)
const {
6704 return VerifyTableStart(verifier) &&
6706 verifier.VerifyVector(padList()) &&
6708 VerifyField<int8_t>(verifier, VT_PADDINGMODE) &&
6709 verifier.EndTable();
6715 flatbuffers::FlatBufferBuilder &
fbb_;
6724 fbb_.AddElement<int8_t>(PadDescriptor::VT_PADDINGMODE,
static_cast<int8_t
>(paddingMode), 0);
6728 start_ = fbb_.StartTable();
6731 flatbuffers::Offset<PadDescriptor>
Finish() {
6732 const auto end = fbb_.EndTable(start_);
6733 auto o = flatbuffers::Offset<PadDescriptor>(end);
6739 flatbuffers::FlatBufferBuilder &_fbb,
6741 float padValue = 0.0f,
6747 return builder_.
Finish();
6751 flatbuffers::FlatBufferBuilder &_fbb,
6752 const std::vector<uint32_t> *padList =
nullptr,
6753 float padValue = 0.0f,
6755 auto padList__ = padList ? _fbb.CreateVector<uint32_t>(*padList) : 0;
6764 struct RsqrtLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6766 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6769 const armnnSerializer::LayerBase *
base()
const {
6770 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6772 bool Verify(flatbuffers::Verifier &verifier)
const {
6773 return VerifyTableStart(verifier) &&
6774 VerifyOffset(verifier,
VT_BASE) &&
6775 verifier.VerifyTable(base()) &&
6776 verifier.EndTable();
6782 flatbuffers::FlatBufferBuilder &
fbb_;
6784 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6789 start_ = fbb_.StartTable();
6793 const auto end = fbb_.EndTable(start_);
6794 auto o = flatbuffers::Offset<RsqrtLayer>(end);
6800 flatbuffers::FlatBufferBuilder &_fbb,
6801 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
6804 return builder_.
Finish();
6807 struct BatchNormalizationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6809 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6817 const armnnSerializer::LayerBase *
base()
const {
6818 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6820 const armnnSerializer::BatchNormalizationDescriptor *
descriptor()
const {
6821 return GetPointer<const armnnSerializer::BatchNormalizationDescriptor *>(
VT_DESCRIPTOR);
6823 const armnnSerializer::ConstTensor *
mean()
const {
6824 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_MEAN);
6827 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_VARIANCE);
6829 const armnnSerializer::ConstTensor *
beta()
const {
6830 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_BETA);
6832 const armnnSerializer::ConstTensor *
gamma()
const {
6833 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_GAMMA);
6835 bool Verify(flatbuffers::Verifier &verifier)
const {
6836 return VerifyTableStart(verifier) &&
6837 VerifyOffset(verifier,
VT_BASE) &&
6838 verifier.VerifyTable(base()) &&
6840 verifier.VerifyTable(descriptor()) &&
6841 VerifyOffset(verifier,
VT_MEAN) &&
6842 verifier.VerifyTable(mean()) &&
6844 verifier.VerifyTable(variance()) &&
6845 VerifyOffset(verifier,
VT_BETA) &&
6846 verifier.VerifyTable(beta()) &&
6847 VerifyOffset(verifier,
VT_GAMMA) &&
6848 verifier.VerifyTable(gamma()) &&
6849 verifier.EndTable();
6855 flatbuffers::FlatBufferBuilder &
fbb_;
6857 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6860 void add_descriptor(flatbuffers::Offset<armnnSerializer::BatchNormalizationDescriptor> descriptor) {
6863 void add_mean(flatbuffers::Offset<armnnSerializer::ConstTensor> mean) {
6866 void add_variance(flatbuffers::Offset<armnnSerializer::ConstTensor> variance) {
6869 void add_beta(flatbuffers::Offset<armnnSerializer::ConstTensor> beta) {
6872 void add_gamma(flatbuffers::Offset<armnnSerializer::ConstTensor> gamma) {
6877 start_ = fbb_.StartTable();
6880 flatbuffers::Offset<BatchNormalizationLayer>
Finish() {
6881 const auto end = fbb_.EndTable(start_);
6882 auto o = flatbuffers::Offset<BatchNormalizationLayer>(end);
6888 flatbuffers::FlatBufferBuilder &_fbb,
6889 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6890 flatbuffers::Offset<armnnSerializer::BatchNormalizationDescriptor> descriptor = 0,
6891 flatbuffers::Offset<armnnSerializer::ConstTensor> mean = 0,
6892 flatbuffers::Offset<armnnSerializer::ConstTensor> variance = 0,
6893 flatbuffers::Offset<armnnSerializer::ConstTensor> beta = 0,
6894 flatbuffers::Offset<armnnSerializer::ConstTensor> gamma = 0) {
6902 return builder_.
Finish();
6905 struct BatchNormalizationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6907 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6912 return GetField<float>(
VT_EPS, 0.0f);
6917 bool Verify(flatbuffers::Verifier &verifier)
const {
6918 return VerifyTableStart(verifier) &&
6919 VerifyField<float>(verifier,
VT_EPS) &&
6921 verifier.EndTable();
6926 typedef BatchNormalizationDescriptor
Table;
6927 flatbuffers::FlatBufferBuilder &
fbb_;
6937 start_ = fbb_.StartTable();
6940 flatbuffers::Offset<BatchNormalizationDescriptor>
Finish() {
6941 const auto end = fbb_.EndTable(start_);
6942 auto o = flatbuffers::Offset<BatchNormalizationDescriptor>(end);
6948 flatbuffers::FlatBufferBuilder &_fbb,
6954 return builder_.
Finish();
6958 struct ResizeBilinearLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6960 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6964 const armnnSerializer::LayerBase *
base()
const {
6965 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6967 const armnnSerializer::ResizeBilinearDescriptor *
descriptor()
const {
6968 return GetPointer<const armnnSerializer::ResizeBilinearDescriptor *>(
VT_DESCRIPTOR);
6970 bool Verify(flatbuffers::Verifier &verifier)
const {
6971 return VerifyTableStart(verifier) &&
6972 VerifyOffset(verifier,
VT_BASE) &&
6973 verifier.VerifyTable(base()) &&
6975 verifier.VerifyTable(descriptor()) &&
6976 verifier.EndTable();
6982 flatbuffers::FlatBufferBuilder &
fbb_;
6984 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6987 void add_descriptor(flatbuffers::Offset<armnnSerializer::ResizeBilinearDescriptor> descriptor) {
6992 start_ = fbb_.StartTable();
6995 flatbuffers::Offset<ResizeBilinearLayer>
Finish() {
6996 const auto end = fbb_.EndTable(start_);
6997 auto o = flatbuffers::Offset<ResizeBilinearLayer>(end);
7003 flatbuffers::FlatBufferBuilder &_fbb,
7004 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7005 flatbuffers::Offset<armnnSerializer::ResizeBilinearDescriptor> descriptor = 0) {
7009 return builder_.
Finish();
7012 struct ResizeBilinearDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7014 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7019 VT_HALFPIXELCENTERS = 12
7034 return GetField<uint8_t>(VT_HALFPIXELCENTERS, 0) != 0;
7036 bool Verify(flatbuffers::Verifier &verifier)
const {
7037 return VerifyTableStart(verifier) &&
7042 VerifyField<uint8_t>(verifier, VT_HALFPIXELCENTERS) &&
7043 verifier.EndTable();
7049 flatbuffers::FlatBufferBuilder &
fbb_;
7064 fbb_.AddElement<uint8_t>(ResizeBilinearDescriptor::VT_HALFPIXELCENTERS,
static_cast<uint8_t
>(halfPixelCenters), 0);
7068 start_ = fbb_.StartTable();
7071 flatbuffers::Offset<ResizeBilinearDescriptor>
Finish() {
7072 const auto end = fbb_.EndTable(start_);
7073 auto o = flatbuffers::Offset<ResizeBilinearDescriptor>(end);
7079 flatbuffers::FlatBufferBuilder &_fbb,
7080 uint32_t targetWidth = 0,
7081 uint32_t targetHeight = 0,
7083 bool alignCorners =
false,
7084 bool halfPixelCenters =
false) {
7091 return builder_.
Finish();
7094 struct SliceLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7096 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7100 const armnnSerializer::LayerBase *
base()
const {
7101 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
7104 return GetPointer<const armnnSerializer::SliceDescriptor *>(
VT_DESCRIPTOR);
7106 bool Verify(flatbuffers::Verifier &verifier)
const {
7107 return VerifyTableStart(verifier) &&
7108 VerifyOffset(verifier,
VT_BASE) &&
7109 verifier.VerifyTable(base()) &&
7111 verifier.VerifyTable(descriptor()) &&
7112 verifier.EndTable();
7118 flatbuffers::FlatBufferBuilder &
fbb_;
7120 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
7123 void add_descriptor(flatbuffers::Offset<armnnSerializer::SliceDescriptor> descriptor) {
7128 start_ = fbb_.StartTable();
7132 const auto end = fbb_.EndTable(start_);
7133 auto o = flatbuffers::Offset<SliceLayer>(end);
7139 flatbuffers::FlatBufferBuilder &_fbb,
7140 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7141 flatbuffers::Offset<armnnSerializer::SliceDescriptor> descriptor = 0) {
7145 return builder_.
Finish();
7148 struct SliceDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7150 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7154 const flatbuffers::Vector<uint32_t> *
begin()
const {
7155 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_BEGIN);
7157 const flatbuffers::Vector<uint32_t> *
size()
const {
7158 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_SIZE);
7160 bool Verify(flatbuffers::Verifier &verifier)
const {
7161 return VerifyTableStart(verifier) &&
7162 VerifyOffset(verifier,
VT_BEGIN) &&
7163 verifier.VerifyVector(begin()) &&
7164 VerifyOffset(verifier, VT_SIZE) &&
7165 verifier.VerifyVector(size()) &&
7166 verifier.EndTable();
7172 flatbuffers::FlatBufferBuilder &
fbb_;
7178 fbb_.AddOffset(SliceDescriptor::VT_SIZE, size);
7182 start_ = fbb_.StartTable();
7185 flatbuffers::Offset<SliceDescriptor>
Finish() {
7186 const auto end = fbb_.EndTable(start_);
7187 auto o = flatbuffers::Offset<SliceDescriptor>(end);
7193 flatbuffers::FlatBufferBuilder &_fbb,
7199 return builder_.
Finish();
7203 flatbuffers::FlatBufferBuilder &_fbb,
7204 const std::vector<uint32_t> *begin =
nullptr,
7205 const std::vector<uint32_t> *size =
nullptr) {
7206 auto begin__ = begin ? _fbb.CreateVector<uint32_t>(*begin) : 0;
7207 auto size__ = size ? _fbb.CreateVector<uint32_t>(*size) : 0;
7214 struct StridedSliceLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7216 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7220 const armnnSerializer::LayerBase *
base()
const {
7221 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
7223 const armnnSerializer::StridedSliceDescriptor *
descriptor()
const {
7224 return GetPointer<const armnnSerializer::StridedSliceDescriptor *>(
VT_DESCRIPTOR);
7226 bool Verify(flatbuffers::Verifier &verifier)
const {
7227 return VerifyTableStart(verifier) &&
7228 VerifyOffset(verifier,
VT_BASE) &&
7229 verifier.VerifyTable(base()) &&
7231 verifier.VerifyTable(descriptor()) &&
7232 verifier.EndTable();
7238 flatbuffers::FlatBufferBuilder &
fbb_;
7240 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
7243 void add_descriptor(flatbuffers::Offset<armnnSerializer::StridedSliceDescriptor> descriptor) {
7248 start_ = fbb_.StartTable();
7251 flatbuffers::Offset<StridedSliceLayer>
Finish() {
7252 const auto end = fbb_.EndTable(start_);
7253 auto o = flatbuffers::Offset<StridedSliceLayer>(end);
7259 flatbuffers::FlatBufferBuilder &_fbb,
7260 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7261 flatbuffers::Offset<armnnSerializer::StridedSliceDescriptor> descriptor = 0) {
7265 return builder_.
Finish();
7268 struct StridedSliceDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7270 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7281 const flatbuffers::Vector<int32_t> *
begin()
const {
7282 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_BEGIN);
7284 const flatbuffers::Vector<int32_t> *
end()
const {
7285 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_END);
7287 const flatbuffers::Vector<int32_t> *
stride()
const {
7288 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_STRIDE);
7308 bool Verify(flatbuffers::Verifier &verifier)
const {
7309 return VerifyTableStart(verifier) &&
7310 VerifyOffset(verifier,
VT_BEGIN) &&
7311 verifier.VerifyVector(begin()) &&
7312 VerifyOffset(verifier,
VT_END) &&
7313 verifier.VerifyVector(end()) &&
7315 verifier.VerifyVector(stride()) &&
7317 VerifyField<int32_t>(verifier,
VT_ENDMASK) &&
7322 verifier.EndTable();
7328 flatbuffers::FlatBufferBuilder &
fbb_;
7359 start_ = fbb_.StartTable();
7362 flatbuffers::Offset<StridedSliceDescriptor>
Finish() {
7363 const auto end = fbb_.EndTable(start_);
7364 auto o = flatbuffers::Offset<StridedSliceDescriptor>(end);
7370 flatbuffers::FlatBufferBuilder &_fbb,
7374 int32_t beginMask = 0,
7375 int32_t endMask = 0,
7376 int32_t shrinkAxisMask = 0,
7377 int32_t ellipsisMask = 0,
7378 int32_t newAxisMask = 0,
7390 return builder_.
Finish();
7394 flatbuffers::FlatBufferBuilder &_fbb,
7395 const std::vector<int32_t> *begin =
nullptr,
7396 const std::vector<int32_t> *end =
nullptr,
7397 const std::vector<int32_t> *stride =
nullptr,
7398 int32_t beginMask = 0,
7399 int32_t endMask = 0,
7400 int32_t shrinkAxisMask = 0,
7401 int32_t ellipsisMask = 0,
7402 int32_t newAxisMask = 0,
7404 auto begin__ = begin ? _fbb.CreateVector<int32_t>(*begin) : 0;
7405 auto end__ = end ? _fbb.CreateVector<int32_t>(*end) : 0;
7406 auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0;
7420 struct ConcatLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7422 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7426 const armnnSerializer::LayerBase *
base()
const {
7427 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
7430 return GetPointer<const armnnSerializer::OriginsDescriptor *>(
VT_DESCRIPTOR);
7432 bool Verify(flatbuffers::Verifier &verifier)
const {
7433 return VerifyTableStart(verifier) &&
7434 VerifyOffset(verifier,
VT_BASE) &&
7435 verifier.VerifyTable(base()) &&
7437 verifier.VerifyTable(descriptor()) &&
7438 verifier.EndTable();
7444 flatbuffers::FlatBufferBuilder &
fbb_;
7446 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
7449 void add_descriptor(flatbuffers::Offset<armnnSerializer::OriginsDescriptor> descriptor) {
7454 start_ = fbb_.StartTable();
7458 const auto end = fbb_.EndTable(start_);
7459 auto o = flatbuffers::Offset<ConcatLayer>(end);
7465 flatbuffers::FlatBufferBuilder &_fbb,
7466 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7467 flatbuffers::Offset<armnnSerializer::OriginsDescriptor> descriptor = 0) {
7471 return builder_.
Finish();
7475 struct MergerLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7477 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7481 const armnnSerializer::LayerBase *
base()
const {
7482 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
7485 return GetPointer<const armnnSerializer::OriginsDescriptor *>(
VT_DESCRIPTOR);
7487 bool Verify(flatbuffers::Verifier &verifier)
const {
7488 return VerifyTableStart(verifier) &&
7489 VerifyOffset(verifier,
VT_BASE) &&
7490 verifier.VerifyTable(base()) &&
7492 verifier.VerifyTable(descriptor()) &&
7493 verifier.EndTable();
7499 flatbuffers::FlatBufferBuilder &
fbb_;
7501 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
7504 void add_descriptor(flatbuffers::Offset<armnnSerializer::OriginsDescriptor> descriptor) {
7509 start_ = fbb_.StartTable();
7513 const auto end = fbb_.EndTable(start_);
7514 auto o = flatbuffers::Offset<MergerLayer>(end);
7520 flatbuffers::FlatBufferBuilder &_fbb,
7521 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7522 flatbuffers::Offset<armnnSerializer::OriginsDescriptor> descriptor = 0) {
7526 return builder_.
Finish();
7529 struct UintVector FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7531 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7534 const flatbuffers::Vector<uint32_t> *
data()
const {
7535 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DATA);
7537 bool Verify(flatbuffers::Verifier &verifier)
const {
7538 return VerifyTableStart(verifier) &&
7539 VerifyOffset(verifier, VT_DATA) &&
7540 verifier.VerifyVector(data()) &&
7541 verifier.EndTable();
7547 flatbuffers::FlatBufferBuilder &
fbb_;
7550 fbb_.AddOffset(UintVector::VT_DATA, data);
7554 start_ = fbb_.StartTable();
7558 const auto end = fbb_.EndTable(start_);
7559 auto o = flatbuffers::Offset<UintVector>(end);
7565 flatbuffers::FlatBufferBuilder &_fbb,
7569 return builder_.
Finish();
7573 flatbuffers::FlatBufferBuilder &_fbb,
7574 const std::vector<uint32_t> *data =
nullptr) {
7575 auto data__ = data ? _fbb.CreateVector<uint32_t>(*data) : 0;
7581 struct OriginsDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7583 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7598 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>> *
viewOrigins()
const {
7599 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>> *>(VT_VIEWORIGINS);
7601 bool Verify(flatbuffers::Verifier &verifier)
const {
7602 return VerifyTableStart(verifier) &&
7606 VerifyOffset(verifier, VT_VIEWORIGINS) &&
7607 verifier.VerifyVector(viewOrigins()) &&
7608 verifier.VerifyVectorOfTables(viewOrigins()) &&
7609 verifier.EndTable();
7615 flatbuffers::FlatBufferBuilder &
fbb_;
7627 fbb_.AddOffset(OriginsDescriptor::VT_VIEWORIGINS, viewOrigins);
7631 start_ = fbb_.StartTable();
7634 flatbuffers::Offset<OriginsDescriptor>
Finish() {
7635 const auto end = fbb_.EndTable(start_);
7636 auto o = flatbuffers::Offset<OriginsDescriptor>(end);
7642 flatbuffers::FlatBufferBuilder &_fbb,
7643 uint32_t concatAxis = 0,
7644 uint32_t numViews = 0,
7645 uint32_t numDimensions = 0,
7646 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>>> viewOrigins = 0) {
7652 return builder_.
Finish();
7656 flatbuffers::FlatBufferBuilder &_fbb,
7657 uint32_t concatAxis = 0,
7658 uint32_t numViews = 0,
7659 uint32_t numDimensions = 0,
7660 const std::vector<flatbuffers::Offset<armnnSerializer::UintVector>> *viewOrigins =
nullptr) {
7661 auto viewOrigins__ = viewOrigins ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::UintVector>>(*viewOrigins) : 0;
7670 struct ViewsDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7672 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7676 const armnnSerializer::OriginsDescriptor *
origins()
const {
7677 return GetPointer<const armnnSerializer::OriginsDescriptor *>(
VT_ORIGINS);
7679 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>> *
viewSizes()
const {
7680 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>> *>(VT_VIEWSIZES);
7682 bool Verify(flatbuffers::Verifier &verifier)
const {
7683 return VerifyTableStart(verifier) &&
7685 verifier.VerifyTable(origins()) &&
7686 VerifyOffset(verifier, VT_VIEWSIZES) &&
7687 verifier.VerifyVector(viewSizes()) &&
7688 verifier.VerifyVectorOfTables(viewSizes()) &&
7689 verifier.EndTable();
7695 flatbuffers::FlatBufferBuilder &
fbb_;
7697 void add_origins(flatbuffers::Offset<armnnSerializer::OriginsDescriptor> origins) {
7701 fbb_.AddOffset(ViewsDescriptor::VT_VIEWSIZES, viewSizes);
7705 start_ = fbb_.StartTable();
7708 flatbuffers::Offset<ViewsDescriptor>
Finish() {
7709 const auto end = fbb_.EndTable(start_);
7710 auto o = flatbuffers::Offset<ViewsDescriptor>(end);
7716 flatbuffers::FlatBufferBuilder &_fbb,
7717 flatbuffers::Offset<armnnSerializer::OriginsDescriptor> origins = 0,
7718 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>>> viewSizes = 0) {
7722 return builder_.
Finish();
7726 flatbuffers::FlatBufferBuilder &_fbb,
7727 flatbuffers::Offset<armnnSerializer::OriginsDescriptor> origins = 0,
7728 const std::vector<flatbuffers::Offset<armnnSerializer::UintVector>> *viewSizes =
nullptr) {
7729 auto viewSizes__ = viewSizes ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::UintVector>>(*viewSizes) : 0;
7736 struct SplitterLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7738 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7742 const armnnSerializer::LayerBase *
base()
const {
7743 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
7746 return GetPointer<const armnnSerializer::ViewsDescriptor *>(
VT_DESCRIPTOR);
7748 bool Verify(flatbuffers::Verifier &verifier)
const {
7749 return VerifyTableStart(verifier) &&
7750 VerifyOffset(verifier,
VT_BASE) &&
7751 verifier.VerifyTable(base()) &&
7753 verifier.VerifyTable(descriptor()) &&
7754 verifier.EndTable();
7760 flatbuffers::FlatBufferBuilder &
fbb_;
7762 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
7765 void add_descriptor(flatbuffers::Offset<armnnSerializer::ViewsDescriptor> descriptor) {
7770 start_ = fbb_.StartTable();
7773 flatbuffers::Offset<SplitterLayer>
Finish() {
7774 const auto end = fbb_.EndTable(start_);
7775 auto o = flatbuffers::Offset<SplitterLayer>(end);
7781 flatbuffers::FlatBufferBuilder &_fbb,
7782 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7783 flatbuffers::Offset<armnnSerializer::ViewsDescriptor> descriptor = 0) {
7787 return builder_.
Finish();
7790 struct DetectionPostProcessLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7792 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7797 const armnnSerializer::LayerBase *
base()
const {
7798 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
7800 const armnnSerializer::DetectionPostProcessDescriptor *
descriptor()
const {
7801 return GetPointer<const armnnSerializer::DetectionPostProcessDescriptor *>(
VT_DESCRIPTOR);
7803 const armnnSerializer::ConstTensor *
anchors()
const {
7804 return GetPointer<const armnnSerializer::ConstTensor *>(VT_ANCHORS);
7806 bool Verify(flatbuffers::Verifier &verifier)
const {
7807 return VerifyTableStart(verifier) &&
7808 VerifyOffset(verifier,
VT_BASE) &&
7809 verifier.VerifyTable(base()) &&
7811 verifier.VerifyTable(descriptor()) &&
7812 VerifyOffset(verifier, VT_ANCHORS) &&
7813 verifier.VerifyTable(anchors()) &&
7814 verifier.EndTable();
7819 typedef DetectionPostProcessLayer
Table;
7820 flatbuffers::FlatBufferBuilder &
fbb_;
7822 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
7825 void add_descriptor(flatbuffers::Offset<armnnSerializer::DetectionPostProcessDescriptor> descriptor) {
7828 void add_anchors(flatbuffers::Offset<armnnSerializer::ConstTensor> anchors) {
7829 fbb_.AddOffset(DetectionPostProcessLayer::VT_ANCHORS, anchors);
7833 start_ = fbb_.StartTable();
7836 flatbuffers::Offset<DetectionPostProcessLayer>
Finish() {
7837 const auto end = fbb_.EndTable(start_);
7838 auto o = flatbuffers::Offset<DetectionPostProcessLayer>(end);
7844 flatbuffers::FlatBufferBuilder &_fbb,
7845 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7846 flatbuffers::Offset<armnnSerializer::DetectionPostProcessDescriptor> descriptor = 0,
7847 flatbuffers::Offset<armnnSerializer::ConstTensor> anchors = 0) {
7852 return builder_.
Finish();
7855 struct DetectionPostProcessDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7857 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7892 return GetField<float>(
VT_SCALEX, 0.0f);
7895 return GetField<float>(
VT_SCALEY, 0.0f);
7898 return GetField<float>(
VT_SCALEW, 0.0f);
7901 return GetField<float>(VT_SCALEH, 0.0f);
7903 bool Verify(flatbuffers::Verifier &verifier)
const {
7904 return VerifyTableStart(verifier) &&
7912 VerifyField<float>(verifier,
VT_SCALEX) &&
7913 VerifyField<float>(verifier,
VT_SCALEY) &&
7914 VerifyField<float>(verifier,
VT_SCALEW) &&
7915 VerifyField<float>(verifier, VT_SCALEH) &&
7916 verifier.EndTable();
7921 typedef DetectionPostProcessDescriptor
Table;
7922 flatbuffers::FlatBufferBuilder &
fbb_;
7955 fbb_.AddElement<
float>(DetectionPostProcessDescriptor::VT_SCALEH, scaleH, 0.0f);
7959 start_ = fbb_.StartTable();
7962 flatbuffers::Offset<DetectionPostProcessDescriptor>
Finish() {
7963 const auto end = fbb_.EndTable(start_);
7964 auto o = flatbuffers::Offset<DetectionPostProcessDescriptor>(end);
7970 flatbuffers::FlatBufferBuilder &_fbb,
7971 uint32_t maxDetections = 0,
7972 uint32_t maxClassesPerDetection = 0,
7973 uint32_t detectionsPerClass = 0,
7974 float nmsScoreThreshold = 0.0f,
7975 float nmsIouThreshold = 0.0f,
7976 uint32_t numClasses = 0,
7977 bool useRegularNms =
false,
7978 float scaleX = 0.0f,
7979 float scaleY = 0.0f,
7980 float scaleW = 0.0f,
7981 float scaleH = 0.0f) {
7994 return builder_.
Finish();
7997 struct LstmInputParams FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7999 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8020 VT_OUTPUTLAYERNORMWEIGHTS = 44
8044 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_CELLBIAS);
8083 return GetPointer<const armnnSerializer::ConstTensor *>(VT_OUTPUTLAYERNORMWEIGHTS);
8085 bool Verify(flatbuffers::Verifier &verifier)
const {
8086 return VerifyTableStart(verifier) &&
8088 verifier.VerifyTable(inputToForgetWeights()) &&
8090 verifier.VerifyTable(inputToCellWeights()) &&
8092 verifier.VerifyTable(inputToOutputWeights()) &&
8094 verifier.VerifyTable(recurrentToForgetWeights()) &&
8096 verifier.VerifyTable(recurrentToCellWeights()) &&
8098 verifier.VerifyTable(recurrentToOutputWeights()) &&
8100 verifier.VerifyTable(forgetGateBias()) &&
8102 verifier.VerifyTable(cellBias()) &&
8104 verifier.VerifyTable(outputGateBias()) &&
8106 verifier.VerifyTable(inputToInputWeights()) &&
8108 verifier.VerifyTable(recurrentToInputWeights()) &&
8110 verifier.VerifyTable(cellToInputWeights()) &&
8112 verifier.VerifyTable(inputGateBias()) &&
8114 verifier.VerifyTable(projectionWeights()) &&
8116 verifier.VerifyTable(projectionBias()) &&
8118 verifier.VerifyTable(cellToForgetWeights()) &&
8120 verifier.VerifyTable(cellToOutputWeights()) &&
8122 verifier.VerifyTable(inputLayerNormWeights()) &&
8124 verifier.VerifyTable(forgetLayerNormWeights()) &&
8126 verifier.VerifyTable(cellLayerNormWeights()) &&
8127 VerifyOffset(verifier, VT_OUTPUTLAYERNORMWEIGHTS) &&
8128 verifier.VerifyTable(outputLayerNormWeights()) &&
8129 verifier.EndTable();
8135 flatbuffers::FlatBufferBuilder &
fbb_;
8158 void add_cellBias(flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias) {
8198 fbb_.AddOffset(LstmInputParams::VT_OUTPUTLAYERNORMWEIGHTS, outputLayerNormWeights);
8202 start_ = fbb_.StartTable();
8205 flatbuffers::Offset<LstmInputParams>
Finish() {
8206 const auto end = fbb_.EndTable(start_);
8207 auto o = flatbuffers::Offset<LstmInputParams>(end);
8213 flatbuffers::FlatBufferBuilder &_fbb,
8214 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToForgetWeights = 0,
8215 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToCellWeights = 0,
8216 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToOutputWeights = 0,
8217 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToForgetWeights = 0,
8218 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToCellWeights = 0,
8219 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToOutputWeights = 0,
8220 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetGateBias = 0,
8221 flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias = 0,
8222 flatbuffers::Offset<armnnSerializer::ConstTensor> outputGateBias = 0,
8223 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToInputWeights = 0,
8224 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToInputWeights = 0,
8225 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToInputWeights = 0,
8226 flatbuffers::Offset<armnnSerializer::ConstTensor> inputGateBias = 0,
8227 flatbuffers::Offset<armnnSerializer::ConstTensor> projectionWeights = 0,
8228 flatbuffers::Offset<armnnSerializer::ConstTensor> projectionBias = 0,
8229 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToForgetWeights = 0,
8230 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToOutputWeights = 0,
8231 flatbuffers::Offset<armnnSerializer::ConstTensor> inputLayerNormWeights = 0,
8232 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetLayerNormWeights = 0,
8233 flatbuffers::Offset<armnnSerializer::ConstTensor> cellLayerNormWeights = 0,
8234 flatbuffers::Offset<armnnSerializer::ConstTensor> outputLayerNormWeights = 0) {
8257 return builder_.
Finish();
8260 struct LstmDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8262 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8292 bool Verify(flatbuffers::Verifier &verifier)
const {
8293 return VerifyTableStart(verifier) &&
8301 verifier.EndTable();
8307 flatbuffers::FlatBufferBuilder &
fbb_;
8332 start_ = fbb_.StartTable();
8335 flatbuffers::Offset<LstmDescriptor>
Finish() {
8336 const auto end = fbb_.EndTable(start_);
8337 auto o = flatbuffers::Offset<LstmDescriptor>(end);
8343 flatbuffers::FlatBufferBuilder &_fbb,
8344 uint32_t activationFunc = 0,
8345 float clippingThresCell = 0.0f,
8346 float clippingThresProj = 0.0f,
8347 bool cifgEnabled =
true,
8348 bool peepholeEnabled =
false,
8349 bool projectionEnabled =
false,
8350 bool layerNormEnabled =
false) {
8359 return builder_.
Finish();
8362 struct LstmLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8364 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8369 const armnnSerializer::LayerBase *
base()
const {
8370 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8373 return GetPointer<const armnnSerializer::LstmDescriptor *>(
VT_DESCRIPTOR);
8376 return GetPointer<const armnnSerializer::LstmInputParams *>(VT_INPUTPARAMS);
8378 bool Verify(flatbuffers::Verifier &verifier)
const {
8379 return VerifyTableStart(verifier) &&
8380 VerifyOffset(verifier,
VT_BASE) &&
8381 verifier.VerifyTable(base()) &&
8383 verifier.VerifyTable(descriptor()) &&
8384 VerifyOffset(verifier, VT_INPUTPARAMS) &&
8385 verifier.VerifyTable(inputParams()) &&
8386 verifier.EndTable();
8392 flatbuffers::FlatBufferBuilder &
fbb_;
8394 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8397 void add_descriptor(flatbuffers::Offset<armnnSerializer::LstmDescriptor> descriptor) {
8401 fbb_.AddOffset(LstmLayer::VT_INPUTPARAMS, inputParams);
8405 start_ = fbb_.StartTable();
8409 const auto end = fbb_.EndTable(start_);
8410 auto o = flatbuffers::Offset<LstmLayer>(end);
8416 flatbuffers::FlatBufferBuilder &_fbb,
8417 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
8418 flatbuffers::Offset<armnnSerializer::LstmDescriptor> descriptor = 0,
8419 flatbuffers::Offset<armnnSerializer::LstmInputParams> inputParams = 0) {
8424 return builder_.
Finish();
8427 struct QLstmInputParams FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8429 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8450 VT_OUTPUTLAYERNORMWEIGHTS = 44
8474 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_CELLBIAS);
8513 return GetPointer<const armnnSerializer::ConstTensor *>(VT_OUTPUTLAYERNORMWEIGHTS);
8515 bool Verify(flatbuffers::Verifier &verifier)
const {
8516 return VerifyTableStart(verifier) &&
8518 verifier.VerifyTable(inputToForgetWeights()) &&
8520 verifier.VerifyTable(inputToCellWeights()) &&
8522 verifier.VerifyTable(inputToOutputWeights()) &&
8524 verifier.VerifyTable(recurrentToForgetWeights()) &&
8526 verifier.VerifyTable(recurrentToCellWeights()) &&
8528 verifier.VerifyTable(recurrentToOutputWeights()) &&
8530 verifier.VerifyTable(forgetGateBias()) &&
8532 verifier.VerifyTable(cellBias()) &&
8534 verifier.VerifyTable(outputGateBias()) &&
8536 verifier.VerifyTable(inputToInputWeights()) &&
8538 verifier.VerifyTable(recurrentToInputWeights()) &&
8540 verifier.VerifyTable(inputGateBias()) &&
8542 verifier.VerifyTable(projectionWeights()) &&
8544 verifier.VerifyTable(projectionBias()) &&
8546 verifier.VerifyTable(cellToInputWeights()) &&
8548 verifier.VerifyTable(cellToForgetWeights()) &&
8550 verifier.VerifyTable(cellToOutputWeights()) &&
8552 verifier.VerifyTable(inputLayerNormWeights()) &&
8554 verifier.VerifyTable(forgetLayerNormWeights()) &&
8556 verifier.VerifyTable(cellLayerNormWeights()) &&
8557 VerifyOffset(verifier, VT_OUTPUTLAYERNORMWEIGHTS) &&
8558 verifier.VerifyTable(outputLayerNormWeights()) &&
8559 verifier.EndTable();
8565 flatbuffers::FlatBufferBuilder &
fbb_;
8588 void add_cellBias(flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias) {
8628 fbb_.AddOffset(QLstmInputParams::VT_OUTPUTLAYERNORMWEIGHTS, outputLayerNormWeights);
8632 start_ = fbb_.StartTable();
8635 flatbuffers::Offset<QLstmInputParams>
Finish() {
8636 const auto end = fbb_.EndTable(start_);
8637 auto o = flatbuffers::Offset<QLstmInputParams>(end);
8643 flatbuffers::FlatBufferBuilder &_fbb,
8644 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToForgetWeights = 0,
8645 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToCellWeights = 0,
8646 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToOutputWeights = 0,
8647 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToForgetWeights = 0,
8648 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToCellWeights = 0,
8649 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToOutputWeights = 0,
8650 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetGateBias = 0,
8651 flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias = 0,
8652 flatbuffers::Offset<armnnSerializer::ConstTensor> outputGateBias = 0,
8653 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToInputWeights = 0,
8654 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToInputWeights = 0,
8655 flatbuffers::Offset<armnnSerializer::ConstTensor> inputGateBias = 0,
8656 flatbuffers::Offset<armnnSerializer::ConstTensor> projectionWeights = 0,
8657 flatbuffers::Offset<armnnSerializer::ConstTensor> projectionBias = 0,
8658 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToInputWeights = 0,
8659 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToForgetWeights = 0,
8660 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToOutputWeights = 0,
8661 flatbuffers::Offset<armnnSerializer::ConstTensor> inputLayerNormWeights = 0,
8662 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetLayerNormWeights = 0,
8663 flatbuffers::Offset<armnnSerializer::ConstTensor> cellLayerNormWeights = 0,
8664 flatbuffers::Offset<armnnSerializer::ConstTensor> outputLayerNormWeights = 0) {
8687 return builder_.
Finish();
8690 struct QLstmDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8692 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8704 VT_HIDDENSTATESCALE = 26
8740 return GetField<float>(VT_HIDDENSTATESCALE, 0.0f);
8742 bool Verify(flatbuffers::Verifier &verifier)
const {
8743 return VerifyTableStart(verifier) &&
8755 VerifyField<float>(verifier, VT_HIDDENSTATESCALE) &&
8756 verifier.EndTable();
8762 flatbuffers::FlatBufferBuilder &
fbb_;
8798 fbb_.AddElement<
float>(QLstmDescriptor::VT_HIDDENSTATESCALE, hiddenStateScale, 0.0f);
8802 start_ = fbb_.StartTable();
8805 flatbuffers::Offset<QLstmDescriptor>
Finish() {
8806 const auto end = fbb_.EndTable(start_);
8807 auto o = flatbuffers::Offset<QLstmDescriptor>(end);
8813 flatbuffers::FlatBufferBuilder &_fbb,
8814 bool cifgEnabled =
true,
8815 bool peepholeEnabled =
false,
8816 bool projectionEnabled =
false,
8817 bool layerNormEnabled =
false,
8818 float cellClip = 0.0f,
8819 float projectionClip = 0.0f,
8820 float inputIntermediateScale = 0.0f,
8821 float forgetIntermediateScale = 0.0f,
8822 float cellIntermediateScale = 0.0f,
8823 float outputIntermediateScale = 0.0f,
8824 int32_t hiddenStateZeroPoint = 0,
8825 float hiddenStateScale = 0.0f) {
8839 return builder_.
Finish();
8842 struct QLstmLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8844 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8849 const armnnSerializer::LayerBase *
base()
const {
8850 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8853 return GetPointer<const armnnSerializer::QLstmDescriptor *>(
VT_DESCRIPTOR);
8856 return GetPointer<const armnnSerializer::QLstmInputParams *>(VT_INPUTPARAMS);
8858 bool Verify(flatbuffers::Verifier &verifier)
const {
8859 return VerifyTableStart(verifier) &&
8860 VerifyOffset(verifier,
VT_BASE) &&
8861 verifier.VerifyTable(base()) &&
8863 verifier.VerifyTable(descriptor()) &&
8864 VerifyOffset(verifier, VT_INPUTPARAMS) &&
8865 verifier.VerifyTable(inputParams()) &&
8866 verifier.EndTable();
8872 flatbuffers::FlatBufferBuilder &
fbb_;
8874 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8877 void add_descriptor(flatbuffers::Offset<armnnSerializer::QLstmDescriptor> descriptor) {
8880 void add_inputParams(flatbuffers::Offset<armnnSerializer::QLstmInputParams> inputParams) {
8881 fbb_.AddOffset(QLstmLayer::VT_INPUTPARAMS, inputParams);
8885 start_ = fbb_.StartTable();
8889 const auto end = fbb_.EndTable(start_);
8890 auto o = flatbuffers::Offset<QLstmLayer>(end);
8896 flatbuffers::FlatBufferBuilder &_fbb,
8897 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
8898 flatbuffers::Offset<armnnSerializer::QLstmDescriptor> descriptor = 0,
8899 flatbuffers::Offset<armnnSerializer::QLstmInputParams> inputParams = 0) {
8904 return builder_.
Finish();
8907 struct QuantizedLstmInputParams FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8909 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8954 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_CELLBIAS);
8959 bool Verify(flatbuffers::Verifier &verifier)
const {
8960 return VerifyTableStart(verifier) &&
8962 verifier.VerifyTable(inputToInputWeights()) &&
8964 verifier.VerifyTable(inputToForgetWeights()) &&
8966 verifier.VerifyTable(inputToCellWeights()) &&
8968 verifier.VerifyTable(inputToOutputWeights()) &&
8970 verifier.VerifyTable(recurrentToInputWeights()) &&
8972 verifier.VerifyTable(recurrentToForgetWeights()) &&
8974 verifier.VerifyTable(recurrentToCellWeights()) &&
8976 verifier.VerifyTable(recurrentToOutputWeights()) &&
8978 verifier.VerifyTable(inputGateBias()) &&
8980 verifier.VerifyTable(forgetGateBias()) &&
8982 verifier.VerifyTable(cellBias()) &&
8984 verifier.VerifyTable(outputGateBias()) &&
8985 verifier.EndTable();
8991 flatbuffers::FlatBufferBuilder &
fbb_;
9023 void add_cellBias(flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias) {
9031 start_ = fbb_.StartTable();
9034 flatbuffers::Offset<QuantizedLstmInputParams>
Finish() {
9035 const auto end = fbb_.EndTable(start_);
9036 auto o = flatbuffers::Offset<QuantizedLstmInputParams>(end);
9042 flatbuffers::FlatBufferBuilder &_fbb,
9043 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToInputWeights = 0,
9044 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToForgetWeights = 0,
9045 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToCellWeights = 0,
9046 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToOutputWeights = 0,
9047 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToInputWeights = 0,
9048 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToForgetWeights = 0,
9049 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToCellWeights = 0,
9050 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToOutputWeights = 0,
9051 flatbuffers::Offset<armnnSerializer::ConstTensor> inputGateBias = 0,
9052 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetGateBias = 0,
9053 flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias = 0,
9054 flatbuffers::Offset<armnnSerializer::ConstTensor> outputGateBias = 0) {
9068 return builder_.
Finish();
9071 struct QuantizedLstmLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9073 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9077 const armnnSerializer::LayerBase *
base()
const {
9078 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9080 const armnnSerializer::QuantizedLstmInputParams *
inputParams()
const {
9081 return GetPointer<const armnnSerializer::QuantizedLstmInputParams *>(VT_INPUTPARAMS);
9083 bool Verify(flatbuffers::Verifier &verifier)
const {
9084 return VerifyTableStart(verifier) &&
9085 VerifyOffset(verifier,
VT_BASE) &&
9086 verifier.VerifyTable(base()) &&
9087 VerifyOffset(verifier, VT_INPUTPARAMS) &&
9088 verifier.VerifyTable(inputParams()) &&
9089 verifier.EndTable();
9095 flatbuffers::FlatBufferBuilder &
fbb_;
9097 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9100 void add_inputParams(flatbuffers::Offset<armnnSerializer::QuantizedLstmInputParams> inputParams) {
9101 fbb_.AddOffset(QuantizedLstmLayer::VT_INPUTPARAMS, inputParams);
9105 start_ = fbb_.StartTable();
9108 flatbuffers::Offset<QuantizedLstmLayer>
Finish() {
9109 const auto end = fbb_.EndTable(start_);
9110 auto o = flatbuffers::Offset<QuantizedLstmLayer>(end);
9116 flatbuffers::FlatBufferBuilder &_fbb,
9117 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9118 flatbuffers::Offset<armnnSerializer::QuantizedLstmInputParams> inputParams = 0) {
9122 return builder_.
Finish();
9125 struct DequantizeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9127 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9130 const armnnSerializer::LayerBase *
base()
const {
9131 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9133 bool Verify(flatbuffers::Verifier &verifier)
const {
9134 return VerifyTableStart(verifier) &&
9135 VerifyOffset(verifier,
VT_BASE) &&
9136 verifier.VerifyTable(base()) &&
9137 verifier.EndTable();
9143 flatbuffers::FlatBufferBuilder &
fbb_;
9145 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9150 start_ = fbb_.StartTable();
9153 flatbuffers::Offset<DequantizeLayer>
Finish() {
9154 const auto end = fbb_.EndTable(start_);
9155 auto o = flatbuffers::Offset<DequantizeLayer>(end);
9161 flatbuffers::FlatBufferBuilder &_fbb,
9162 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
9165 return builder_.
Finish();
9168 struct MergeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9170 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9173 const armnnSerializer::LayerBase *
base()
const {
9174 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9176 bool Verify(flatbuffers::Verifier &verifier)
const {
9177 return VerifyTableStart(verifier) &&
9178 VerifyOffset(verifier,
VT_BASE) &&
9179 verifier.VerifyTable(base()) &&
9180 verifier.EndTable();
9186 flatbuffers::FlatBufferBuilder &
fbb_;
9188 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9193 start_ = fbb_.StartTable();
9197 const auto end = fbb_.EndTable(start_);
9198 auto o = flatbuffers::Offset<MergeLayer>(end);
9204 flatbuffers::FlatBufferBuilder &_fbb,
9205 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
9208 return builder_.
Finish();
9211 struct SwitchLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9213 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9216 const armnnSerializer::LayerBase *
base()
const {
9217 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9219 bool Verify(flatbuffers::Verifier &verifier)
const {
9220 return VerifyTableStart(verifier) &&
9221 VerifyOffset(verifier,
VT_BASE) &&
9222 verifier.VerifyTable(base()) &&
9223 verifier.EndTable();
9229 flatbuffers::FlatBufferBuilder &
fbb_;
9231 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9236 start_ = fbb_.StartTable();
9240 const auto end = fbb_.EndTable(start_);
9241 auto o = flatbuffers::Offset<SwitchLayer>(end);
9247 flatbuffers::FlatBufferBuilder &_fbb,
9248 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
9251 return builder_.
Finish();
9254 struct PreluLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9256 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9259 const armnnSerializer::LayerBase *
base()
const {
9260 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9262 bool Verify(flatbuffers::Verifier &verifier)
const {
9263 return VerifyTableStart(verifier) &&
9264 VerifyOffset(verifier,
VT_BASE) &&
9265 verifier.VerifyTable(base()) &&
9266 verifier.EndTable();
9272 flatbuffers::FlatBufferBuilder &
fbb_;
9274 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9279 start_ = fbb_.StartTable();
9283 const auto end = fbb_.EndTable(start_);
9284 auto o = flatbuffers::Offset<PreluLayer>(end);
9290 flatbuffers::FlatBufferBuilder &_fbb,
9291 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
9294 return builder_.
Finish();
9297 struct TransposeConvolution2dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9299 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9305 const armnnSerializer::LayerBase *
base()
const {
9306 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9308 const armnnSerializer::TransposeConvolution2dDescriptor *
descriptor()
const {
9309 return GetPointer<const armnnSerializer::TransposeConvolution2dDescriptor *>(
VT_DESCRIPTOR);
9311 const armnnSerializer::ConstTensor *
weights()
const {
9312 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_WEIGHTS);
9314 const armnnSerializer::ConstTensor *
biases()
const {
9315 return GetPointer<const armnnSerializer::ConstTensor *>(VT_BIASES);
9317 bool Verify(flatbuffers::Verifier &verifier)
const {
9318 return VerifyTableStart(verifier) &&
9319 VerifyOffset(verifier,
VT_BASE) &&
9320 verifier.VerifyTable(base()) &&
9322 verifier.VerifyTable(descriptor()) &&
9324 verifier.VerifyTable(weights()) &&
9325 VerifyOffset(verifier, VT_BIASES) &&
9326 verifier.VerifyTable(biases()) &&
9327 verifier.EndTable();
9332 typedef TransposeConvolution2dLayer
Table;
9333 flatbuffers::FlatBufferBuilder &
fbb_;
9335 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9338 void add_descriptor(flatbuffers::Offset<armnnSerializer::TransposeConvolution2dDescriptor> descriptor) {
9341 void add_weights(flatbuffers::Offset<armnnSerializer::ConstTensor> weights) {
9344 void add_biases(flatbuffers::Offset<armnnSerializer::ConstTensor> biases) {
9345 fbb_.AddOffset(TransposeConvolution2dLayer::VT_BIASES, biases);
9349 start_ = fbb_.StartTable();
9352 flatbuffers::Offset<TransposeConvolution2dLayer>
Finish() {
9353 const auto end = fbb_.EndTable(start_);
9354 auto o = flatbuffers::Offset<TransposeConvolution2dLayer>(end);
9360 flatbuffers::FlatBufferBuilder &_fbb,
9361 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9362 flatbuffers::Offset<armnnSerializer::TransposeConvolution2dDescriptor> descriptor = 0,
9363 flatbuffers::Offset<armnnSerializer::ConstTensor> weights = 0,
9364 flatbuffers::Offset<armnnSerializer::ConstTensor> biases = 0) {
9370 return builder_.
Finish();
9373 struct TransposeConvolution2dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9375 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9392 return GetField<uint32_t>(
VT_PADTOP, 0);
9409 bool Verify(flatbuffers::Verifier &verifier)
const {
9410 return VerifyTableStart(verifier) &&
9411 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
9413 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
9415 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
9416 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
9419 verifier.EndTable();
9424 typedef TransposeConvolution2dDescriptor
Table;
9425 flatbuffers::FlatBufferBuilder &
fbb_;
9453 start_ = fbb_.StartTable();
9456 flatbuffers::Offset<TransposeConvolution2dDescriptor>
Finish() {
9457 const auto end = fbb_.EndTable(start_);
9458 auto o = flatbuffers::Offset<TransposeConvolution2dDescriptor>(end);
9464 flatbuffers::FlatBufferBuilder &_fbb,
9465 uint32_t padLeft = 0,
9466 uint32_t padRight = 0,
9467 uint32_t padTop = 0,
9468 uint32_t padBottom = 0,
9469 uint32_t strideX = 0,
9470 uint32_t strideY = 0,
9471 bool biasEnabled =
false,
9482 return builder_.
Finish();
9485 struct TransposeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9487 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9491 const armnnSerializer::LayerBase *
base()
const {
9492 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9495 return GetPointer<const armnnSerializer::TransposeDescriptor *>(
VT_DESCRIPTOR);
9497 bool Verify(flatbuffers::Verifier &verifier)
const {
9498 return VerifyTableStart(verifier) &&
9499 VerifyOffset(verifier,
VT_BASE) &&
9500 verifier.VerifyTable(base()) &&
9502 verifier.VerifyTable(descriptor()) &&
9503 verifier.EndTable();
9509 flatbuffers::FlatBufferBuilder &
fbb_;
9511 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9514 void add_descriptor(flatbuffers::Offset<armnnSerializer::TransposeDescriptor> descriptor) {
9519 start_ = fbb_.StartTable();
9522 flatbuffers::Offset<TransposeLayer>
Finish() {
9523 const auto end = fbb_.EndTable(start_);
9524 auto o = flatbuffers::Offset<TransposeLayer>(end);
9530 flatbuffers::FlatBufferBuilder &_fbb,
9531 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9532 flatbuffers::Offset<armnnSerializer::TransposeDescriptor> descriptor = 0) {
9536 return builder_.
Finish();
9539 struct TransposeDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9541 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9545 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DIMMAPPINGS);
9547 bool Verify(flatbuffers::Verifier &verifier)
const {
9548 return VerifyTableStart(verifier) &&
9549 VerifyOffset(verifier, VT_DIMMAPPINGS) &&
9550 verifier.VerifyVector(dimMappings()) &&
9551 verifier.EndTable();
9557 flatbuffers::FlatBufferBuilder &
fbb_;
9560 fbb_.AddOffset(TransposeDescriptor::VT_DIMMAPPINGS, dimMappings);
9564 start_ = fbb_.StartTable();
9567 flatbuffers::Offset<TransposeDescriptor>
Finish() {
9568 const auto end = fbb_.EndTable(start_);
9569 auto o = flatbuffers::Offset<TransposeDescriptor>(end);
9575 flatbuffers::FlatBufferBuilder &_fbb,
9579 return builder_.
Finish();
9583 flatbuffers::FlatBufferBuilder &_fbb,
9584 const std::vector<uint32_t> *dimMappings =
nullptr) {
9585 auto dimMappings__ = dimMappings ? _fbb.CreateVector<uint32_t>(*dimMappings) : 0;
9591 struct ResizeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9593 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9597 const armnnSerializer::LayerBase *
base()
const {
9598 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9601 return GetPointer<const armnnSerializer::ResizeDescriptor *>(
VT_DESCRIPTOR);
9603 bool Verify(flatbuffers::Verifier &verifier)
const {
9604 return VerifyTableStart(verifier) &&
9605 VerifyOffset(verifier,
VT_BASE) &&
9606 verifier.VerifyTable(base()) &&
9608 verifier.VerifyTable(descriptor()) &&
9609 verifier.EndTable();
9615 flatbuffers::FlatBufferBuilder &
fbb_;
9617 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9620 void add_descriptor(flatbuffers::Offset<armnnSerializer::ResizeDescriptor> descriptor) {
9625 start_ = fbb_.StartTable();
9629 const auto end = fbb_.EndTable(start_);
9630 auto o = flatbuffers::Offset<ResizeLayer>(end);
9636 flatbuffers::FlatBufferBuilder &_fbb,
9637 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9638 flatbuffers::Offset<armnnSerializer::ResizeDescriptor> descriptor = 0) {
9642 return builder_.
Finish();
9645 struct ResizeDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9647 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9653 VT_HALFPIXELCENTERS = 14
9671 return GetField<uint8_t>(VT_HALFPIXELCENTERS, 0) != 0;
9673 bool Verify(flatbuffers::Verifier &verifier)
const {
9674 return VerifyTableStart(verifier) &&
9677 VerifyField<int8_t>(verifier,
VT_METHOD) &&
9680 VerifyField<uint8_t>(verifier, VT_HALFPIXELCENTERS) &&
9681 verifier.EndTable();
9687 flatbuffers::FlatBufferBuilder &
fbb_;
9705 fbb_.AddElement<uint8_t>(ResizeDescriptor::VT_HALFPIXELCENTERS,
static_cast<uint8_t
>(halfPixelCenters), 0);
9709 start_ = fbb_.StartTable();
9712 flatbuffers::Offset<ResizeDescriptor>
Finish() {
9713 const auto end = fbb_.EndTable(start_);
9714 auto o = flatbuffers::Offset<ResizeDescriptor>(end);
9720 flatbuffers::FlatBufferBuilder &_fbb,
9721 uint32_t targetHeight = 0,
9722 uint32_t targetWidth = 0,
9725 bool alignCorners =
false,
9726 bool halfPixelCenters =
false) {
9734 return builder_.
Finish();
9737 struct StackLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9739 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9743 const armnnSerializer::LayerBase *
base()
const {
9744 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9747 return GetPointer<const armnnSerializer::StackDescriptor *>(
VT_DESCRIPTOR);
9749 bool Verify(flatbuffers::Verifier &verifier)
const {
9750 return VerifyTableStart(verifier) &&
9751 VerifyOffset(verifier,
VT_BASE) &&
9752 verifier.VerifyTable(base()) &&
9754 verifier.VerifyTable(descriptor()) &&
9755 verifier.EndTable();
9761 flatbuffers::FlatBufferBuilder &
fbb_;
9763 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9766 void add_descriptor(flatbuffers::Offset<armnnSerializer::StackDescriptor> descriptor) {
9771 start_ = fbb_.StartTable();
9775 const auto end = fbb_.EndTable(start_);
9776 auto o = flatbuffers::Offset<StackLayer>(end);
9782 flatbuffers::FlatBufferBuilder &_fbb,
9783 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9784 flatbuffers::Offset<armnnSerializer::StackDescriptor> descriptor = 0) {
9788 return builder_.
Finish();
9791 struct StackDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9793 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9799 return GetField<uint32_t>(
VT_AXIS, 0);
9805 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_INPUTSHAPE);
9807 bool Verify(flatbuffers::Verifier &verifier)
const {
9808 return VerifyTableStart(verifier) &&
9809 VerifyField<uint32_t>(verifier,
VT_AXIS) &&
9811 VerifyOffset(verifier, VT_INPUTSHAPE) &&
9812 verifier.VerifyVector(inputShape()) &&
9813 verifier.EndTable();
9819 flatbuffers::FlatBufferBuilder &
fbb_;
9828 fbb_.AddOffset(StackDescriptor::VT_INPUTSHAPE, inputShape);
9832 start_ = fbb_.StartTable();
9835 flatbuffers::Offset<StackDescriptor>
Finish() {
9836 const auto end = fbb_.EndTable(start_);
9837 auto o = flatbuffers::Offset<StackDescriptor>(end);
9843 flatbuffers::FlatBufferBuilder &_fbb,
9845 uint32_t numInputs = 0,
9851 return builder_.
Finish();
9855 flatbuffers::FlatBufferBuilder &_fbb,
9857 uint32_t numInputs = 0,
9858 const std::vector<uint32_t> *inputShape =
nullptr) {
9859 auto inputShape__ = inputShape ? _fbb.CreateVector<uint32_t>(*inputShape) : 0;
9867 struct StandInDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9869 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9877 return GetField<uint32_t>(VT_NUMOUTPUTS, 0);
9879 bool Verify(flatbuffers::Verifier &verifier)
const {
9880 return VerifyTableStart(verifier) &&
9882 VerifyField<uint32_t>(verifier, VT_NUMOUTPUTS) &&
9883 verifier.EndTable();
9889 flatbuffers::FlatBufferBuilder &
fbb_;
9895 fbb_.AddElement<uint32_t>(StandInDescriptor::VT_NUMOUTPUTS, numOutputs, 0);
9899 start_ = fbb_.StartTable();
9902 flatbuffers::Offset<StandInDescriptor>
Finish() {
9903 const auto end = fbb_.EndTable(start_);
9904 auto o = flatbuffers::Offset<StandInDescriptor>(end);
9910 flatbuffers::FlatBufferBuilder &_fbb,
9911 uint32_t numInputs = 0,
9912 uint32_t numOutputs = 0) {
9916 return builder_.
Finish();
9919 struct StandInLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9921 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9925 const armnnSerializer::LayerBase *
base()
const {
9926 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9929 return GetPointer<const armnnSerializer::StandInDescriptor *>(
VT_DESCRIPTOR);
9931 bool Verify(flatbuffers::Verifier &verifier)
const {
9932 return VerifyTableStart(verifier) &&
9933 VerifyOffset(verifier,
VT_BASE) &&
9934 verifier.VerifyTable(base()) &&
9936 verifier.VerifyTable(descriptor()) &&
9937 verifier.EndTable();
9943 flatbuffers::FlatBufferBuilder &
fbb_;
9945 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9948 void add_descriptor(flatbuffers::Offset<armnnSerializer::StandInDescriptor> descriptor) {
9953 start_ = fbb_.StartTable();
9957 const auto end = fbb_.EndTable(start_);
9958 auto o = flatbuffers::Offset<StandInLayer>(end);
9964 flatbuffers::FlatBufferBuilder &_fbb,
9965 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9966 flatbuffers::Offset<armnnSerializer::StandInDescriptor> descriptor = 0) {
9970 return builder_.
Finish();
9973 struct RankLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9975 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9978 const armnnSerializer::LayerBase *
base()
const {
9979 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9981 bool Verify(flatbuffers::Verifier &verifier)
const {
9982 return VerifyTableStart(verifier) &&
9983 VerifyOffset(verifier,
VT_BASE) &&
9984 verifier.VerifyTable(base()) &&
9985 verifier.EndTable();
9991 flatbuffers::FlatBufferBuilder &
fbb_;
9993 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9998 start_ = fbb_.StartTable();
10002 const auto end = fbb_.EndTable(start_);
10003 auto o = flatbuffers::Offset<RankLayer>(end);
10009 flatbuffers::FlatBufferBuilder &_fbb,
10010 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
10013 return builder_.
Finish();
10016 struct ReduceLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
10018 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10022 const armnnSerializer::LayerBase *
base()
const {
10023 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
10026 return GetPointer<const armnnSerializer::ReduceDescriptor *>(
VT_DESCRIPTOR);
10028 bool Verify(flatbuffers::Verifier &verifier)
const {
10029 return VerifyTableStart(verifier) &&
10030 VerifyOffset(verifier,
VT_BASE) &&
10031 verifier.VerifyTable(base()) &&
10033 verifier.VerifyTable(descriptor()) &&
10034 verifier.EndTable();
10042 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
10050 start_ = fbb_.StartTable();
10054 const auto end = fbb_.EndTable(start_);
10055 auto o = flatbuffers::Offset<ReduceLayer>(end);
10061 flatbuffers::FlatBufferBuilder &_fbb,
10062 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
10063 flatbuffers::Offset<armnnSerializer::ReduceDescriptor> descriptor = 0) {
10067 return builder_.
Finish();
10070 struct ReduceDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
10072 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10075 VT_REDUCEOPERATION = 8
10080 const flatbuffers::Vector<uint32_t> *
axis()
const {
10081 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_AXIS);
10086 bool Verify(flatbuffers::Verifier &verifier)
const {
10087 return VerifyTableStart(verifier) &&
10089 VerifyOffset(verifier,
VT_AXIS) &&
10090 verifier.VerifyVector(axis()) &&
10091 VerifyField<int8_t>(verifier, VT_REDUCEOPERATION) &&
10092 verifier.EndTable();
10107 fbb_.AddElement<int8_t>(ReduceDescriptor::VT_REDUCEOPERATION,
static_cast<int8_t
>(reduceOperation), 0);
10111 start_ = fbb_.StartTable();
10115 const auto end = fbb_.EndTable(start_);
10116 auto o = flatbuffers::Offset<ReduceDescriptor>(end);
10122 flatbuffers::FlatBufferBuilder &_fbb,
10123 bool keepDims =
false,
10130 return builder_.
Finish();
10134 flatbuffers::FlatBufferBuilder &_fbb,
10135 bool keepDims =
false,
10136 const std::vector<uint32_t> *axis =
nullptr,
10138 auto axis__ = axis ? _fbb.CreateVector<uint32_t>(*axis) : 0;
10148 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10180 return GetField<uint8_t>(VT_TIMEMAJOR, 0) != 0;
10182 bool Verify(flatbuffers::Verifier &verifier)
const {
10183 return VerifyTableStart(verifier) &&
10191 VerifyField<uint8_t>(verifier, VT_TIMEMAJOR) &&
10192 verifier.EndTable();
10222 fbb_.AddElement<uint8_t>(UnidirectionalSequenceLstmDescriptor::VT_TIMEMAJOR,
static_cast<uint8_t
>(timeMajor), 0);
10226 start_ = fbb_.StartTable();
10229 flatbuffers::Offset<UnidirectionalSequenceLstmDescriptor>
Finish() {
10230 const auto end = fbb_.EndTable(start_);
10231 auto o = flatbuffers::Offset<UnidirectionalSequenceLstmDescriptor>(end);
10237 flatbuffers::FlatBufferBuilder &_fbb,
10238 uint32_t activationFunc = 0,
10239 float clippingThresCell = 0.0f,
10240 float clippingThresProj = 0.0f,
10241 bool cifgEnabled =
true,
10242 bool peepholeEnabled =
false,
10243 bool projectionEnabled =
false,
10244 bool layerNormEnabled =
false,
10245 bool timeMajor =
false) {
10255 return builder_.
Finish();
10258 struct UnidirectionalSequenceLstmLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
10260 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10265 const armnnSerializer::LayerBase *
base()
const {
10266 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
10269 return GetPointer<const armnnSerializer::UnidirectionalSequenceLstmDescriptor *>(
VT_DESCRIPTOR);
10272 return GetPointer<const armnnSerializer::LstmInputParams *>(VT_INPUTPARAMS);
10274 bool Verify(flatbuffers::Verifier &verifier)
const {
10275 return VerifyTableStart(verifier) &&
10276 VerifyOffset(verifier,
VT_BASE) &&
10277 verifier.VerifyTable(base()) &&
10279 verifier.VerifyTable(descriptor()) &&
10280 VerifyOffset(verifier, VT_INPUTPARAMS) &&
10281 verifier.VerifyTable(inputParams()) &&
10282 verifier.EndTable();
10287 typedef UnidirectionalSequenceLstmLayer
Table;
10290 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
10293 void add_descriptor(flatbuffers::Offset<armnnSerializer::UnidirectionalSequenceLstmDescriptor> descriptor) {
10297 fbb_.AddOffset(UnidirectionalSequenceLstmLayer::VT_INPUTPARAMS, inputParams);
10301 start_ = fbb_.StartTable();
10304 flatbuffers::Offset<UnidirectionalSequenceLstmLayer>
Finish() {
10305 const auto end = fbb_.EndTable(start_);
10306 auto o = flatbuffers::Offset<UnidirectionalSequenceLstmLayer>(end);
10312 flatbuffers::FlatBufferBuilder &_fbb,
10313 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
10314 flatbuffers::Offset<armnnSerializer::UnidirectionalSequenceLstmDescriptor> descriptor = 0,
10315 flatbuffers::Offset<armnnSerializer::LstmInputParams> inputParams = 0) {
10320 return builder_.
Finish();
10323 struct AnyLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
10325 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10333 return GetPointer<const void *>(VT_LAYER);
10335 template<
typename T>
const T *layer_as()
const;
10537 bool Verify(flatbuffers::Verifier &verifier)
const {
10538 return VerifyTableStart(verifier) &&
10540 VerifyOffset(verifier, VT_LAYER) &&
10542 verifier.EndTable();
10546 template<>
inline const armnnSerializer::ActivationLayer *AnyLayer::layer_as<armnnSerializer::ActivationLayer>()
const {
10547 return layer_as_ActivationLayer();
10550 template<>
inline const armnnSerializer::AdditionLayer *AnyLayer::layer_as<armnnSerializer::AdditionLayer>()
const {
10551 return layer_as_AdditionLayer();
10554 template<>
inline const armnnSerializer::BatchToSpaceNdLayer *AnyLayer::layer_as<armnnSerializer::BatchToSpaceNdLayer>()
const {
10555 return layer_as_BatchToSpaceNdLayer();
10558 template<>
inline const armnnSerializer::BatchNormalizationLayer *AnyLayer::layer_as<armnnSerializer::BatchNormalizationLayer>()
const {
10559 return layer_as_BatchNormalizationLayer();
10562 template<>
inline const armnnSerializer::ConstantLayer *AnyLayer::layer_as<armnnSerializer::ConstantLayer>()
const {
10563 return layer_as_ConstantLayer();
10566 template<>
inline const armnnSerializer::Convolution2dLayer *AnyLayer::layer_as<armnnSerializer::Convolution2dLayer>()
const {
10567 return layer_as_Convolution2dLayer();
10570 template<>
inline const armnnSerializer::DepthwiseConvolution2dLayer *AnyLayer::layer_as<armnnSerializer::DepthwiseConvolution2dLayer>()
const {
10571 return layer_as_DepthwiseConvolution2dLayer();
10574 template<>
inline const armnnSerializer::FullyConnectedLayer *AnyLayer::layer_as<armnnSerializer::FullyConnectedLayer>()
const {
10575 return layer_as_FullyConnectedLayer();
10578 template<>
inline const armnnSerializer::InputLayer *AnyLayer::layer_as<armnnSerializer::InputLayer>()
const {
10579 return layer_as_InputLayer();
10582 template<>
inline const armnnSerializer::MultiplicationLayer *AnyLayer::layer_as<armnnSerializer::MultiplicationLayer>()
const {
10583 return layer_as_MultiplicationLayer();
10586 template<>
inline const armnnSerializer::OutputLayer *AnyLayer::layer_as<armnnSerializer::OutputLayer>()
const {
10587 return layer_as_OutputLayer();
10590 template<>
inline const armnnSerializer::PermuteLayer *AnyLayer::layer_as<armnnSerializer::PermuteLayer>()
const {
10591 return layer_as_PermuteLayer();
10594 template<>
inline const armnnSerializer::Pooling2dLayer *AnyLayer::layer_as<armnnSerializer::Pooling2dLayer>()
const {
10595 return layer_as_Pooling2dLayer();
10598 template<>
inline const armnnSerializer::ReshapeLayer *AnyLayer::layer_as<armnnSerializer::ReshapeLayer>()
const {
10599 return layer_as_ReshapeLayer();
10602 template<>
inline const armnnSerializer::SoftmaxLayer *AnyLayer::layer_as<armnnSerializer::SoftmaxLayer>()
const {
10603 return layer_as_SoftmaxLayer();
10606 template<>
inline const armnnSerializer::SpaceToBatchNdLayer *AnyLayer::layer_as<armnnSerializer::SpaceToBatchNdLayer>()
const {
10607 return layer_as_SpaceToBatchNdLayer();
10610 template<>
inline const armnnSerializer::DivisionLayer *AnyLayer::layer_as<armnnSerializer::DivisionLayer>()
const {
10611 return layer_as_DivisionLayer();
10614 template<>
inline const armnnSerializer::MinimumLayer *AnyLayer::layer_as<armnnSerializer::MinimumLayer>()
const {
10615 return layer_as_MinimumLayer();
10618 template<>
inline const armnnSerializer::EqualLayer *AnyLayer::layer_as<armnnSerializer::EqualLayer>()
const {
10619 return layer_as_EqualLayer();
10622 template<>
inline const armnnSerializer::MaximumLayer *AnyLayer::layer_as<armnnSerializer::MaximumLayer>()
const {
10623 return layer_as_MaximumLayer();
10626 template<>
inline const armnnSerializer::NormalizationLayer *AnyLayer::layer_as<armnnSerializer::NormalizationLayer>()
const {
10627 return layer_as_NormalizationLayer();
10630 template<>
inline const armnnSerializer::PadLayer *AnyLayer::layer_as<armnnSerializer::PadLayer>()
const {
10631 return layer_as_PadLayer();
10634 template<>
inline const armnnSerializer::RsqrtLayer *AnyLayer::layer_as<armnnSerializer::RsqrtLayer>()
const {
10635 return layer_as_RsqrtLayer();
10638 template<>
inline const armnnSerializer::FloorLayer *AnyLayer::layer_as<armnnSerializer::FloorLayer>()
const {
10639 return layer_as_FloorLayer();
10642 template<>
inline const armnnSerializer::GreaterLayer *AnyLayer::layer_as<armnnSerializer::GreaterLayer>()
const {
10643 return layer_as_GreaterLayer();
10646 template<>
inline const armnnSerializer::ResizeBilinearLayer *AnyLayer::layer_as<armnnSerializer::ResizeBilinearLayer>()
const {
10647 return layer_as_ResizeBilinearLayer();
10650 template<>
inline const armnnSerializer::SubtractionLayer *AnyLayer::layer_as<armnnSerializer::SubtractionLayer>()
const {
10651 return layer_as_SubtractionLayer();
10654 template<>
inline const armnnSerializer::StridedSliceLayer *AnyLayer::layer_as<armnnSerializer::StridedSliceLayer>()
const {
10655 return layer_as_StridedSliceLayer();
10658 template<>
inline const armnnSerializer::GatherLayer *AnyLayer::layer_as<armnnSerializer::GatherLayer>()
const {
10659 return layer_as_GatherLayer();
10662 template<>
inline const armnnSerializer::MeanLayer *AnyLayer::layer_as<armnnSerializer::MeanLayer>()
const {
10663 return layer_as_MeanLayer();
10667 return layer_as_MergerLayer();
10670 template<>
inline const armnnSerializer::L2NormalizationLayer *AnyLayer::layer_as<armnnSerializer::L2NormalizationLayer>()
const {
10671 return layer_as_L2NormalizationLayer();
10674 template<>
inline const armnnSerializer::SplitterLayer *AnyLayer::layer_as<armnnSerializer::SplitterLayer>()
const {
10675 return layer_as_SplitterLayer();
10678 template<>
inline const armnnSerializer::DetectionPostProcessLayer *AnyLayer::layer_as<armnnSerializer::DetectionPostProcessLayer>()
const {
10679 return layer_as_DetectionPostProcessLayer();
10682 template<>
inline const armnnSerializer::LstmLayer *AnyLayer::layer_as<armnnSerializer::LstmLayer>()
const {
10683 return layer_as_LstmLayer();
10686 template<>
inline const armnnSerializer::QuantizedLstmLayer *AnyLayer::layer_as<armnnSerializer::QuantizedLstmLayer>()
const {
10687 return layer_as_QuantizedLstmLayer();
10690 template<>
inline const armnnSerializer::QuantizeLayer *AnyLayer::layer_as<armnnSerializer::QuantizeLayer>()
const {
10691 return layer_as_QuantizeLayer();
10694 template<>
inline const armnnSerializer::DequantizeLayer *AnyLayer::layer_as<armnnSerializer::DequantizeLayer>()
const {
10695 return layer_as_DequantizeLayer();
10698 template<>
inline const armnnSerializer::MergeLayer *AnyLayer::layer_as<armnnSerializer::MergeLayer>()
const {
10699 return layer_as_MergeLayer();
10702 template<>
inline const armnnSerializer::SwitchLayer *AnyLayer::layer_as<armnnSerializer::SwitchLayer>()
const {
10703 return layer_as_SwitchLayer();
10706 template<>
inline const armnnSerializer::ConcatLayer *AnyLayer::layer_as<armnnSerializer::ConcatLayer>()
const {
10707 return layer_as_ConcatLayer();
10710 template<>
inline const armnnSerializer::SpaceToDepthLayer *AnyLayer::layer_as<armnnSerializer::SpaceToDepthLayer>()
const {
10711 return layer_as_SpaceToDepthLayer();
10714 template<>
inline const armnnSerializer::PreluLayer *AnyLayer::layer_as<armnnSerializer::PreluLayer>()
const {
10715 return layer_as_PreluLayer();
10718 template<>
inline const armnnSerializer::TransposeConvolution2dLayer *AnyLayer::layer_as<armnnSerializer::TransposeConvolution2dLayer>()
const {
10719 return layer_as_TransposeConvolution2dLayer();
10722 template<>
inline const armnnSerializer::ResizeLayer *AnyLayer::layer_as<armnnSerializer::ResizeLayer>()
const {
10723 return layer_as_ResizeLayer();
10726 template<>
inline const armnnSerializer::StackLayer *AnyLayer::layer_as<armnnSerializer::StackLayer>()
const {
10727 return layer_as_StackLayer();
10730 template<>
inline const armnnSerializer::AbsLayer *AnyLayer::layer_as<armnnSerializer::AbsLayer>()
const {
10731 return layer_as_AbsLayer();
10734 template<>
inline const armnnSerializer::ArgMinMaxLayer *AnyLayer::layer_as<armnnSerializer::ArgMinMaxLayer>()
const {
10735 return layer_as_ArgMinMaxLayer();
10738 template<>
inline const armnnSerializer::SliceLayer *AnyLayer::layer_as<armnnSerializer::SliceLayer>()
const {
10739 return layer_as_SliceLayer();
10742 template<>
inline const armnnSerializer::DepthToSpaceLayer *AnyLayer::layer_as<armnnSerializer::DepthToSpaceLayer>()
const {
10743 return layer_as_DepthToSpaceLayer();
10746 template<>
inline const armnnSerializer::InstanceNormalizationLayer *AnyLayer::layer_as<armnnSerializer::InstanceNormalizationLayer>()
const {
10747 return layer_as_InstanceNormalizationLayer();
10750 template<>
inline const armnnSerializer::LogSoftmaxLayer *AnyLayer::layer_as<armnnSerializer::LogSoftmaxLayer>()
const {
10751 return layer_as_LogSoftmaxLayer();
10754 template<>
inline const armnnSerializer::ComparisonLayer *AnyLayer::layer_as<armnnSerializer::ComparisonLayer>()
const {
10755 return layer_as_ComparisonLayer();
10758 template<>
inline const armnnSerializer::StandInLayer *AnyLayer::layer_as<armnnSerializer::StandInLayer>()
const {
10759 return layer_as_StandInLayer();
10762 template<>
inline const armnnSerializer::ElementwiseUnaryLayer *AnyLayer::layer_as<armnnSerializer::ElementwiseUnaryLayer>()
const {
10763 return layer_as_ElementwiseUnaryLayer();
10766 template<>
inline const armnnSerializer::TransposeLayer *AnyLayer::layer_as<armnnSerializer::TransposeLayer>()
const {
10767 return layer_as_TransposeLayer();
10770 template<>
inline const armnnSerializer::QLstmLayer *AnyLayer::layer_as<armnnSerializer::QLstmLayer>()
const {
10771 return layer_as_QLstmLayer();
10774 template<>
inline const armnnSerializer::FillLayer *AnyLayer::layer_as<armnnSerializer::FillLayer>()
const {
10775 return layer_as_FillLayer();
10778 template<>
inline const armnnSerializer::RankLayer *AnyLayer::layer_as<armnnSerializer::RankLayer>()
const {
10779 return layer_as_RankLayer();
10782 template<>
inline const armnnSerializer::LogicalBinaryLayer *AnyLayer::layer_as<armnnSerializer::LogicalBinaryLayer>()
const {
10783 return layer_as_LogicalBinaryLayer();
10786 template<>
inline const armnnSerializer::ReduceLayer *AnyLayer::layer_as<armnnSerializer::ReduceLayer>()
const {
10787 return layer_as_ReduceLayer();
10790 template<>
inline const armnnSerializer::CastLayer *AnyLayer::layer_as<armnnSerializer::CastLayer>()
const {
10791 return layer_as_CastLayer();
10794 template<>
inline const armnnSerializer::ShapeLayer *AnyLayer::layer_as<armnnSerializer::ShapeLayer>()
const {
10795 return layer_as_ShapeLayer();
10798 template<>
inline const armnnSerializer::UnidirectionalSequenceLstmLayer *AnyLayer::layer_as<armnnSerializer::UnidirectionalSequenceLstmLayer>()
const {
10799 return layer_as_UnidirectionalSequenceLstmLayer();
10802 template<>
inline const armnnSerializer::ChannelShuffleLayer *AnyLayer::layer_as<armnnSerializer::ChannelShuffleLayer>()
const {
10803 return layer_as_ChannelShuffleLayer();
10806 template<>
inline const armnnSerializer::Convolution3dLayer *AnyLayer::layer_as<armnnSerializer::Convolution3dLayer>()
const {
10807 return layer_as_Convolution3dLayer();
10810 template<>
inline const armnnSerializer::Pooling3dLayer *AnyLayer::layer_as<armnnSerializer::Pooling3dLayer>()
const {
10811 return layer_as_Pooling3dLayer();
10822 fbb_.AddOffset(AnyLayer::VT_LAYER, layer);
10826 start_ = fbb_.StartTable();
10830 const auto end = fbb_.EndTable(start_);
10831 auto o = flatbuffers::Offset<AnyLayer>(end);
10837 flatbuffers::FlatBufferBuilder &_fbb,
10839 flatbuffers::Offset<void> layer = 0) {
10843 return builder_.
Finish();
10846 struct FeatureCompatibilityVersions FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
10848 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10851 VT_CONSTANTTENSORSASINPUTS = 8
10860 return GetField<uint32_t>(VT_CONSTANTTENSORSASINPUTS, 0);
10862 bool Verify(flatbuffers::Verifier &verifier)
const {
10863 return VerifyTableStart(verifier) &&
10866 VerifyField<uint32_t>(verifier, VT_CONSTANTTENSORSASINPUTS) &&
10867 verifier.EndTable();
10882 fbb_.AddElement<uint32_t>(FeatureCompatibilityVersions::VT_CONSTANTTENSORSASINPUTS, constantTensorsAsInputs, 0);
10886 start_ = fbb_.StartTable();
10889 flatbuffers::Offset<FeatureCompatibilityVersions>
Finish() {
10890 const auto end = fbb_.EndTable(start_);
10891 auto o = flatbuffers::Offset<FeatureCompatibilityVersions>(end);
10897 flatbuffers::FlatBufferBuilder &_fbb,
10898 uint32_t bindingIdsScheme = 0,
10899 uint32_t weightsLayoutScheme = 0,
10900 uint32_t constantTensorsAsInputs = 0) {
10905 return builder_.
Finish();
10908 struct SerializedGraph FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
10910 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10914 VT_FEATUREVERSIONS = 10
10916 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::AnyLayer>> *
layers()
const {
10917 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::AnyLayer>> *>(
VT_LAYERS);
10920 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_INPUTIDS);
10923 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_OUTPUTIDS);
10926 return GetPointer<const armnnSerializer::FeatureCompatibilityVersions *>(VT_FEATUREVERSIONS);
10928 bool Verify(flatbuffers::Verifier &verifier)
const {
10929 return VerifyTableStart(verifier) &&
10931 verifier.VerifyVector(layers()) &&
10932 verifier.VerifyVectorOfTables(layers()) &&
10934 verifier.VerifyVector(inputIds()) &&
10936 verifier.VerifyVector(outputIds()) &&
10937 VerifyOffset(verifier, VT_FEATUREVERSIONS) &&
10938 verifier.VerifyTable(featureVersions()) &&
10939 verifier.EndTable();
10957 fbb_.AddOffset(SerializedGraph::VT_FEATUREVERSIONS, featureVersions);
10961 start_ = fbb_.StartTable();
10965 const auto end = fbb_.EndTable(start_);
10966 auto o = flatbuffers::Offset<SerializedGraph>(end);
10972 flatbuffers::FlatBufferBuilder &_fbb,
10973 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::AnyLayer>>> layers = 0,
10976 flatbuffers::Offset<armnnSerializer::FeatureCompatibilityVersions> featureVersions = 0) {
10982 return builder_.
Finish();
10986 flatbuffers::FlatBufferBuilder &_fbb,
10987 const std::vector<flatbuffers::Offset<armnnSerializer::AnyLayer>> *layers =
nullptr,
10988 const std::vector<int32_t> *inputIds =
nullptr,
10989 const std::vector<int32_t> *outputIds =
nullptr,
10990 flatbuffers::Offset<armnnSerializer::FeatureCompatibilityVersions> featureVersions = 0) {
10991 auto layers__ = layers ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::AnyLayer>>(*layers) : 0;
10992 auto inputIds__ = inputIds ? _fbb.CreateVector<int32_t>(*inputIds) : 0;
10993 auto outputIds__ = outputIds ? _fbb.CreateVector<int32_t>(*outputIds) : 0;
11008 auto ptr =
reinterpret_cast<const armnnSerializer::ByteData *
>(obj);
11009 return verifier.VerifyTable(ptr);
11012 auto ptr =
reinterpret_cast<const armnnSerializer::ShortData *
>(obj);
11013 return verifier.VerifyTable(ptr);
11016 auto ptr =
reinterpret_cast<const armnnSerializer::IntData *
>(obj);
11017 return verifier.VerifyTable(ptr);
11020 auto ptr =
reinterpret_cast<const armnnSerializer::LongData *
>(obj);
11021 return verifier.VerifyTable(ptr);
11023 default:
return true;
11027 inline bool VerifyConstTensorDataVector(flatbuffers::Verifier &verifier,
const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
const flatbuffers::Vector<uint8_t> *types) {
11028 if (!values || !types)
return !values && !types;
11029 if (values->size() != types->size())
return false;
11030 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
11045 auto ptr =
reinterpret_cast<const armnnSerializer::ActivationLayer *
>(obj);
11046 return verifier.VerifyTable(ptr);
11049 auto ptr =
reinterpret_cast<const armnnSerializer::AdditionLayer *
>(obj);
11050 return verifier.VerifyTable(ptr);
11053 auto ptr =
reinterpret_cast<const armnnSerializer::BatchToSpaceNdLayer *
>(obj);
11054 return verifier.VerifyTable(ptr);
11057 auto ptr =
reinterpret_cast<const armnnSerializer::BatchNormalizationLayer *
>(obj);
11058 return verifier.VerifyTable(ptr);
11061 auto ptr =
reinterpret_cast<const armnnSerializer::ConstantLayer *
>(obj);
11062 return verifier.VerifyTable(ptr);
11065 auto ptr =
reinterpret_cast<const armnnSerializer::Convolution2dLayer *
>(obj);
11066 return verifier.VerifyTable(ptr);
11069 auto ptr =
reinterpret_cast<const armnnSerializer::DepthwiseConvolution2dLayer *
>(obj);
11070 return verifier.VerifyTable(ptr);
11073 auto ptr =
reinterpret_cast<const armnnSerializer::FullyConnectedLayer *
>(obj);
11074 return verifier.VerifyTable(ptr);
11077 auto ptr =
reinterpret_cast<const armnnSerializer::InputLayer *
>(obj);
11078 return verifier.VerifyTable(ptr);
11081 auto ptr =
reinterpret_cast<const armnnSerializer::MultiplicationLayer *
>(obj);
11082 return verifier.VerifyTable(ptr);
11085 auto ptr =
reinterpret_cast<const armnnSerializer::OutputLayer *
>(obj);
11086 return verifier.VerifyTable(ptr);
11089 auto ptr =
reinterpret_cast<const armnnSerializer::PermuteLayer *
>(obj);
11090 return verifier.VerifyTable(ptr);
11093 auto ptr =
reinterpret_cast<const armnnSerializer::Pooling2dLayer *
>(obj);
11094 return verifier.VerifyTable(ptr);
11097 auto ptr =
reinterpret_cast<const armnnSerializer::ReshapeLayer *
>(obj);
11098 return verifier.VerifyTable(ptr);
11101 auto ptr =
reinterpret_cast<const armnnSerializer::SoftmaxLayer *
>(obj);
11102 return verifier.VerifyTable(ptr);
11105 auto ptr =
reinterpret_cast<const armnnSerializer::SpaceToBatchNdLayer *
>(obj);
11106 return verifier.VerifyTable(ptr);
11109 auto ptr =
reinterpret_cast<const armnnSerializer::DivisionLayer *
>(obj);
11110 return verifier.VerifyTable(ptr);
11113 auto ptr =
reinterpret_cast<const armnnSerializer::MinimumLayer *
>(obj);
11114 return verifier.VerifyTable(ptr);
11117 auto ptr =
reinterpret_cast<const armnnSerializer::EqualLayer *
>(obj);
11118 return verifier.VerifyTable(ptr);
11121 auto ptr =
reinterpret_cast<const armnnSerializer::MaximumLayer *
>(obj);
11122 return verifier.VerifyTable(ptr);
11125 auto ptr =
reinterpret_cast<const armnnSerializer::NormalizationLayer *
>(obj);
11126 return verifier.VerifyTable(ptr);
11129 auto ptr =
reinterpret_cast<const armnnSerializer::PadLayer *
>(obj);
11130 return verifier.VerifyTable(ptr);
11133 auto ptr =
reinterpret_cast<const armnnSerializer::RsqrtLayer *
>(obj);
11134 return verifier.VerifyTable(ptr);
11137 auto ptr =
reinterpret_cast<const armnnSerializer::FloorLayer *
>(obj);
11138 return verifier.VerifyTable(ptr);
11141 auto ptr =
reinterpret_cast<const armnnSerializer::GreaterLayer *
>(obj);
11142 return verifier.VerifyTable(ptr);
11145 auto ptr =
reinterpret_cast<const armnnSerializer::ResizeBilinearLayer *
>(obj);
11146 return verifier.VerifyTable(ptr);
11149 auto ptr =
reinterpret_cast<const armnnSerializer::SubtractionLayer *
>(obj);
11150 return verifier.VerifyTable(ptr);
11153 auto ptr =
reinterpret_cast<const armnnSerializer::StridedSliceLayer *
>(obj);
11154 return verifier.VerifyTable(ptr);
11157 auto ptr =
reinterpret_cast<const armnnSerializer::GatherLayer *
>(obj);
11158 return verifier.VerifyTable(ptr);
11161 auto ptr =
reinterpret_cast<const armnnSerializer::MeanLayer *
>(obj);
11162 return verifier.VerifyTable(ptr);
11166 return verifier.VerifyTable(ptr);
11169 auto ptr =
reinterpret_cast<const armnnSerializer::L2NormalizationLayer *
>(obj);
11170 return verifier.VerifyTable(ptr);
11173 auto ptr =
reinterpret_cast<const armnnSerializer::SplitterLayer *
>(obj);
11174 return verifier.VerifyTable(ptr);
11177 auto ptr =
reinterpret_cast<const armnnSerializer::DetectionPostProcessLayer *
>(obj);
11178 return verifier.VerifyTable(ptr);
11181 auto ptr =
reinterpret_cast<const armnnSerializer::LstmLayer *
>(obj);
11182 return verifier.VerifyTable(ptr);
11185 auto ptr =
reinterpret_cast<const armnnSerializer::QuantizedLstmLayer *
>(obj);
11186 return verifier.VerifyTable(ptr);
11189 auto ptr =
reinterpret_cast<const armnnSerializer::QuantizeLayer *
>(obj);
11190 return verifier.VerifyTable(ptr);
11193 auto ptr =
reinterpret_cast<const armnnSerializer::DequantizeLayer *
>(obj);
11194 return verifier.VerifyTable(ptr);
11197 auto ptr =
reinterpret_cast<const armnnSerializer::MergeLayer *
>(obj);
11198 return verifier.VerifyTable(ptr);
11201 auto ptr =
reinterpret_cast<const armnnSerializer::SwitchLayer *
>(obj);
11202 return verifier.VerifyTable(ptr);
11205 auto ptr =
reinterpret_cast<const armnnSerializer::ConcatLayer *
>(obj);
11206 return verifier.VerifyTable(ptr);
11209 auto ptr =
reinterpret_cast<const armnnSerializer::SpaceToDepthLayer *
>(obj);
11210 return verifier.VerifyTable(ptr);
11213 auto ptr =
reinterpret_cast<const armnnSerializer::PreluLayer *
>(obj);
11214 return verifier.VerifyTable(ptr);
11217 auto ptr =
reinterpret_cast<const armnnSerializer::TransposeConvolution2dLayer *
>(obj);
11218 return verifier.VerifyTable(ptr);
11221 auto ptr =
reinterpret_cast<const armnnSerializer::ResizeLayer *
>(obj);
11222 return verifier.VerifyTable(ptr);
11225 auto ptr =
reinterpret_cast<const armnnSerializer::StackLayer *
>(obj);
11226 return verifier.VerifyTable(ptr);
11229 auto ptr =
reinterpret_cast<const armnnSerializer::AbsLayer *
>(obj);
11230 return verifier.VerifyTable(ptr);
11233 auto ptr =
reinterpret_cast<const armnnSerializer::ArgMinMaxLayer *
>(obj);
11234 return verifier.VerifyTable(ptr);
11237 auto ptr =
reinterpret_cast<const armnnSerializer::SliceLayer *
>(obj);
11238 return verifier.VerifyTable(ptr);
11241 auto ptr =
reinterpret_cast<const armnnSerializer::DepthToSpaceLayer *
>(obj);
11242 return verifier.VerifyTable(ptr);
11245 auto ptr =
reinterpret_cast<const armnnSerializer::InstanceNormalizationLayer *
>(obj);
11246 return verifier.VerifyTable(ptr);
11249 auto ptr =
reinterpret_cast<const armnnSerializer::LogSoftmaxLayer *
>(obj);
11250 return verifier.VerifyTable(ptr);
11253 auto ptr =
reinterpret_cast<const armnnSerializer::ComparisonLayer *
>(obj);
11254 return verifier.VerifyTable(ptr);
11257 auto ptr =
reinterpret_cast<const armnnSerializer::StandInLayer *
>(obj);
11258 return verifier.VerifyTable(ptr);
11261 auto ptr =
reinterpret_cast<const armnnSerializer::ElementwiseUnaryLayer *
>(obj);
11262 return verifier.VerifyTable(ptr);
11265 auto ptr =
reinterpret_cast<const armnnSerializer::TransposeLayer *
>(obj);
11266 return verifier.VerifyTable(ptr);
11269 auto ptr =
reinterpret_cast<const armnnSerializer::QLstmLayer *
>(obj);
11270 return verifier.VerifyTable(ptr);
11273 auto ptr =
reinterpret_cast<const armnnSerializer::FillLayer *
>(obj);
11274 return verifier.VerifyTable(ptr);
11277 auto ptr =
reinterpret_cast<const armnnSerializer::RankLayer *
>(obj);
11278 return verifier.VerifyTable(ptr);
11281 auto ptr =
reinterpret_cast<const armnnSerializer::LogicalBinaryLayer *
>(obj);
11282 return verifier.VerifyTable(ptr);
11285 auto ptr =
reinterpret_cast<const armnnSerializer::ReduceLayer *
>(obj);
11286 return verifier.VerifyTable(ptr);
11289 auto ptr =
reinterpret_cast<const armnnSerializer::CastLayer *
>(obj);
11290 return verifier.VerifyTable(ptr);
11293 auto ptr =
reinterpret_cast<const armnnSerializer::ShapeLayer *
>(obj);
11294 return verifier.VerifyTable(ptr);
11297 auto ptr =
reinterpret_cast<const armnnSerializer::UnidirectionalSequenceLstmLayer *
>(obj);
11298 return verifier.VerifyTable(ptr);
11301 auto ptr =
reinterpret_cast<const armnnSerializer::ChannelShuffleLayer *
>(obj);
11302 return verifier.VerifyTable(ptr);
11305 auto ptr =
reinterpret_cast<const armnnSerializer::Convolution3dLayer *
>(obj);
11306 return verifier.VerifyTable(ptr);
11309 auto ptr =
reinterpret_cast<const armnnSerializer::Pooling3dLayer *
>(obj);
11310 return verifier.VerifyTable(ptr);
11312 default:
return true;
11316 inline bool VerifyLayerVector(flatbuffers::Verifier &verifier,
const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
const flatbuffers::Vector<uint8_t> *types) {
11317 if (!values || !types)
return !values && !types;
11318 if (values->size() != types->size())
return false;
11319 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
11321 verifier, values->Get(i), types->GetEnum<
Layer>(i))) {
11329 return flatbuffers::GetRoot<armnnSerializer::SerializedGraph>(buf);
11333 return flatbuffers::GetSizePrefixedRoot<armnnSerializer::SerializedGraph>(buf);
11341 return flatbuffers::BufferHasIdentifier(
11346 flatbuffers::Verifier &verifier) {
11351 flatbuffers::Verifier &verifier) {
11360 flatbuffers::FlatBufferBuilder &fbb,
11361 flatbuffers::Offset<armnnSerializer::SerializedGraph> root) {
11366 flatbuffers::FlatBufferBuilder &fbb,
11367 flatbuffers::Offset<armnnSerializer::SerializedGraph> root) {
11373 #endif // FLATBUFFERS_GENERATED_ARMNNSCHEMA_ARMNNSERIALIZER_H_ flatbuffers::uoffset_t start_
flatbuffers::Offset< LayerBase > CreateLayerBaseDirect(flatbuffers::FlatBufferBuilder &_fbb, uint32_t index=0, const char *layerName=nullptr, armnnSerializer::LayerType layerType=armnnSerializer::LayerType_Addition, const std::vector< flatbuffers::Offset< armnnSerializer::InputSlot >> *inputSlots=nullptr, const std::vector< flatbuffers::Offset< armnnSerializer::OutputSlot >> *outputSlots=nullptr)
void add_endMask(int32_t endMask)
const armnnSerializer::ConstTensor * weights() const
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
void add_clippingThresCell(float clippingThresCell)
flatbuffers::Offset< MeanLayer > Finish()
flatbuffers::Offset< CastLayer > Finish()
flatbuffers::Offset< TensorInfo > Finish()
const armnnSerializer::RankLayer * layer_as_RankLayer() const
LogSoftmaxDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_poolType(armnnSerializer::PoolingAlgorithm poolType)
flatbuffers::Offset< DepthToSpaceDescriptor > Finish()
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
MultiplicationLayerBuilder Builder
flatbuffers::uoffset_t start_
void add_descriptor(flatbuffers::Offset< armnnSerializer::NormalizationDescriptor > descriptor)
uint32_t padFront() const
flatbuffers::Offset< DepthToSpaceLayer > Finish()
ChannelShuffleDescriptor Table
float projectionClip() const
void add_normSize(uint32_t normSize)
const armnnSerializer::ConstTensor * inputToOutputWeights() const
ConstantLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_anchors(flatbuffers::Offset< armnnSerializer::ConstTensor > anchors)
uint32_t numClasses() const
const armnnSerializer::AdditionLayer * layer_as_AdditionLayer() const
ReduceDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< SplitterLayer > Finish()
flatbuffers::Offset< Convolution3dDescriptor > CreateConvolution3dDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t padLeft=0, uint32_t padRight=0, uint32_t padTop=0, uint32_t padBottom=0, uint32_t padFront=0, uint32_t padBack=0, uint32_t strideX=0, uint32_t strideY=0, uint32_t strideZ=0, uint32_t dilationX=1, uint32_t dilationY=1, uint32_t dilationZ=1, bool biasEnabled=false, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NDHWC)
flatbuffers::Offset< LongData > CreateLongData(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< int64_t >> data=0)
void add_scaleW(float scaleW)
uint32_t targetHeight() const
flatbuffers::uoffset_t start_
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
ElementwiseUnaryLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_ellipsisMask(int32_t ellipsisMask)
const armnnSerializer::UnidirectionalSequenceLstmDescriptor * descriptor() const
flatbuffers::FlatBufferBuilder & fbb_
MinimumLayerBuilder Builder
flatbuffers::Offset< LongData > Finish()
void add_strideX(uint32_t strideX)
flatbuffers::uoffset_t start_
Pooling3dLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< ElementwiseUnaryDescriptor > Finish()
FullyConnectedDescriptor Table
const armnnSerializer::MaximumLayer * layer_as_MaximumLayer() const
ElementwiseUnaryDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
TransposeLayerBuilder Builder
void add_descriptor(flatbuffers::Offset< armnnSerializer::ResizeBilinearDescriptor > descriptor)
ViewsDescriptorBuilder Builder
QuantizedLstmLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< ReshapeDescriptor > CreateReshapeDescriptor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> targetShape=0)
Convolution3dLayerBuilder Builder
const armnnSerializer::SliceLayer * layer_as_SliceLayer() const
flatbuffers::FlatBufferBuilder & fbb_
SubtractionLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
RsqrtLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< ReduceLayer > CreateReduceLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ReduceDescriptor > descriptor=0)
void add_descriptor(flatbuffers::Offset< armnnSerializer::SpaceToBatchNdDescriptor > descriptor)
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
int32_t beginMask() const
const armnnSerializer::ConcatLayer * layer_as_ConcatLayer() const
static const ConstTensorData enum_value
flatbuffers::uoffset_t start_
void add_info(flatbuffers::Offset< armnnSerializer::TensorInfo > info)
flatbuffers::Offset< SerializedGraph > CreateSerializedGraphDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< flatbuffers::Offset< armnnSerializer::AnyLayer >> *layers=nullptr, const std::vector< int32_t > *inputIds=nullptr, const std::vector< int32_t > *outputIds=nullptr, flatbuffers::Offset< armnnSerializer::FeatureCompatibilityVersions > featureVersions=0)
ConcatLayerBuilder Builder
const char * EnumNameUnaryOperation(UnaryOperation e)
flatbuffers::Offset< PermuteLayer > Finish()
const armnnSerializer::ConstTensor * inputGateBias() const
const armnnSerializer::NormalizationLayer * layer_as_NormalizationLayer() const
void add_layerNormEnabled(bool layerNormEnabled)
BatchToSpaceNdLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::FillDescriptor * descriptor() const
const Layer(& EnumValuesLayer())[68]
void add_isConstant(bool isConstant)
flatbuffers::FlatBufferBuilder & fbb_
void add_maxClassesPerDetection(uint32_t maxClassesPerDetection)
void add_dilationY(uint32_t dilationY)
const armnnSerializer::PermuteLayer * layer_as_PermuteLayer() const
void add_activationFunc(uint32_t activationFunc)
flatbuffers::Offset< OutputSlot > CreateOutputSlot(flatbuffers::FlatBufferBuilder &_fbb, uint32_t index=0, flatbuffers::Offset< armnnSerializer::TensorInfo > tensorInfo=0)
flatbuffers::Offset< QLstmDescriptor > Finish()
armnnSerializer::NormalizationAlgorithmMethod normMethodType() const
flatbuffers::Offset< DepthwiseConvolution2dDescriptor > CreateDepthwiseConvolution2dDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t padLeft=0, uint32_t padRight=0, uint32_t padTop=0, uint32_t padBottom=0, uint32_t strideX=0, uint32_t strideY=0, uint32_t dilationX=1, uint32_t dilationY=1, bool biasEnabled=false, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NCHW)
void add_data_type(armnnSerializer::ConstTensorData data_type)
uint32_t padBottom() const
MergerLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
const armnnSerializer::QLstmDescriptor * descriptor() const
SliceDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
MultiplicationLayer Table
const armnnSerializer::ConstTensor * recurrentToForgetWeights() const
ConcatLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const char *const * EnumNamesLogicalBinaryOperation()
ElementwiseUnaryDescriptorBuilder Builder
const armnnSerializer::ComparisonDescriptor * descriptor() const
const armnnSerializer::FeatureCompatibilityVersions * featureVersions() const
armnnSerializer::DataType dataType() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
float cellIntermediateScale() const
armnnSerializer::LogicalBinaryOperation operation() const
const char *const * EnumNamesReduceOperation()
AdditionLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::RsqrtLayer * layer_as_RsqrtLayer() const
void add_descriptor(flatbuffers::Offset< armnnSerializer::SliceDescriptor > descriptor)
flatbuffers::Offset< UnidirectionalSequenceLstmLayer > Finish()
const armnnSerializer::CastLayer * layer_as_CastLayer() const
LstmLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_descriptor(flatbuffers::Offset< armnnSerializer::TransposeDescriptor > descriptor)
flatbuffers::Offset< ActivationLayer > Finish()
BatchNormalizationLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Pooling3dDescriptor Table
bool VerifyLayerVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector< flatbuffers::Offset< void >> *values, const flatbuffers::Vector< uint8_t > *types)
void add_descriptor(flatbuffers::Offset< armnnSerializer::BatchToSpaceNdDescriptor > descriptor)
TransposeConvolution2dLayerBuilder Builder
const armnnSerializer::ElementwiseUnaryDescriptor * descriptor() const
void add_descriptor(flatbuffers::Offset< armnnSerializer::GatherDescriptor > descriptor)
flatbuffers::Offset< TransposeConvolution2dLayer > Finish()
armnnSerializer::LayerType layerType() const
const char *const * EnumNamesPaddingMode()
const armnnSerializer::ConstTensor * outputLayerNormWeights() const
const armnnSerializer::ConstTensor * cellLayerNormWeights() const
void add_quantizationScale(float quantizationScale)
flatbuffers::Offset< MaximumLayer > Finish()
Pooling3dLayerBuilder Builder
const DataType(& EnumValuesDataType())[11]
flatbuffers::Offset< MergerLayer > CreateMergerLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::OriginsDescriptor > descriptor=0)
flatbuffers::uoffset_t start_
void add_poolHeight(uint32_t poolHeight)
void add_padRight(uint32_t padRight)
flatbuffers::Offset< AbsLayer > CreateAbsLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
flatbuffers::Offset< LstmLayer > CreateLstmLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::LstmDescriptor > descriptor=0, flatbuffers::Offset< armnnSerializer::LstmInputParams > inputParams=0)
uint32_t padRight() const
flatbuffers::Offset< PermuteDescriptor > Finish()
flatbuffers::Offset< L2NormalizationLayer > CreateL2NormalizationLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::L2NormalizationDescriptor > descriptor=0)
flatbuffers::FlatBufferBuilder & fbb_
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::FlatBufferBuilder & fbb_
void add_constantWeights(bool constantWeights)
const armnnSerializer::Convolution2dLayer * layer_as_Convolution2dLayer() const
ConstTensorBuilder Builder
const flatbuffers::Vector< int16_t > * data() const
const flatbuffers::Vector< uint32_t > * blockShape() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_method(armnnSerializer::ResizeMethod method)
flatbuffers::uoffset_t start_
void add_padTop(uint32_t padTop)
flatbuffers::Offset< TransposeConvolution2dDescriptor > CreateTransposeConvolution2dDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t padLeft=0, uint32_t padRight=0, uint32_t padTop=0, uint32_t padBottom=0, uint32_t strideX=0, uint32_t strideY=0, bool biasEnabled=false, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NCHW)
void add_index(uint32_t index)
flatbuffers::Offset< GatherLayer > Finish()
ShapeLayerBuilder Builder
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
ResizeBilinearLayerBuilder Builder
const flatbuffers::Vector< uint32_t > * dimMappings() const
void add_beta(float beta)
bool VerifyLayer(flatbuffers::Verifier &verifier, const void *obj, Layer type)
SpaceToBatchNdLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
ActivationDescriptorBuilder Builder
void add_poolDepth(uint32_t poolDepth)
const flatbuffers::Vector< int32_t > * end() const
SoftmaxDescriptorBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< LogSoftmaxLayer > Finish()
ShapeLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_weights(flatbuffers::Offset< armnnSerializer::ConstTensor > weights)
uint32_t maxClassesPerDetection() const
Pooling3dDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_biases(flatbuffers::Offset< armnnSerializer::ConstTensor > biases)
void add_descriptor(flatbuffers::Offset< armnnSerializer::FullyConnectedDescriptor > descriptor)
unsigned int Offset(const TensorShape &shape, unsigned int batch, unsigned int height, unsigned int width, unsigned int channels, const DataLayoutIndexed &dataLayout)
SubtractionLayerBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< ResizeDescriptor > CreateResizeDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t targetHeight=0, uint32_t targetWidth=0, armnnSerializer::ResizeMethod method=armnnSerializer::ResizeMethod_NearestNeighbor, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC, bool alignCorners=false, bool halfPixelCenters=false)
flatbuffers::Offset< FillLayer > CreateFillLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::FillDescriptor > descriptor=0)
void add_padLeft(uint32_t padLeft)
const char *const * EnumNamesResizeMethod()
flatbuffers::FlatBufferBuilder & fbb_
SpaceToBatchNdDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const armnnSerializer::UnidirectionalSequenceLstmLayer * layer_as_UnidirectionalSequenceLstmLayer() const
NormalizationDescriptorBuilder Builder
FillDescriptorBuilder Builder
void add_numGroups(uint32_t numGroups)
const char *const * EnumNamesDataLayout()
flatbuffers::Offset< ShortData > CreateShortDataDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< int16_t > *data=nullptr)
flatbuffers::Offset< IntData > CreateIntDataDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< int32_t > *data=nullptr)
void add_normMethodType(armnnSerializer::NormalizationAlgorithmMethod normMethodType)
const char *const * EnumNamesActivationFunction()
MergeLayerBuilder Builder
void add_descriptor(flatbuffers::Offset< armnnSerializer::PadDescriptor > descriptor)
void add_halfPixelCenters(bool halfPixelCenters)
flatbuffers::uoffset_t start_
void add_peepholeEnabled(bool peepholeEnabled)
NormalizationAlgorithmChannel
flatbuffers::FlatBufferBuilder & fbb_
ArgMinMaxDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
bool projectionEnabled() const
Convolution3dDescriptorBuilder Builder
void add_quantizationOffset(int32_t quantizationOffset)
flatbuffers::uoffset_t start_
void add_layerNormEnabled(bool layerNormEnabled)
flatbuffers::uoffset_t start_
flatbuffers::Offset< StackDescriptor > CreateStackDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, uint32_t axis=0, uint32_t numInputs=0, const std::vector< uint32_t > *inputShape=nullptr)
ArgMinMaxDescriptor Table
InputLayerBuilder Builder
flatbuffers::Offset< LogicalBinaryDescriptor > Finish()
GatherLayerBuilder Builder
void add_numClasses(uint32_t numClasses)
flatbuffers::FlatBufferBuilder & fbb_
armnnSerializer::ReduceOperation reduceOperation() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::Offset< DequantizeLayer > Finish()
void add_padLeft(uint32_t padLeft)
ViewsDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
LstmDescriptorBuilder Builder
flatbuffers::Offset< LongData > CreateLongDataDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< int64_t > *data=nullptr)
void add_descriptor(flatbuffers::Offset< armnnSerializer::ActivationDescriptor > descriptor)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
TransposeDescriptorBuilder Builder
SwitchLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_viewSizes(flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::UintVector >>> viewSizes)
void add_projectionEnabled(bool projectionEnabled)
void add_begin(flatbuffers::Offset< flatbuffers::Vector< int32_t >> begin)
const armnnSerializer::ByteData * data_as_ByteData() const
DetectionPostProcessLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::ShapeLayer * layer_as_ShapeLayer() const
flatbuffers::uoffset_t start_
void add_targetWidth(uint32_t targetWidth)
armnnSerializer::Layer layer_type() const
flatbuffers::uoffset_t start_
const armnnSerializer::ElementwiseUnaryLayer * layer_as_ElementwiseUnaryLayer() const
flatbuffers::FlatBufferBuilder & fbb_
void add_descriptor(flatbuffers::Offset< armnnSerializer::LogicalBinaryDescriptor > descriptor)
StandInLayerBuilder Builder
int32_t ellipsisMask() const
const armnnSerializer::ConstTensor * gamma() const
flatbuffers::Offset< GatherLayer > CreateGatherLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::GatherDescriptor > descriptor=0)
Pooling2dLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_descriptor(flatbuffers::Offset< armnnSerializer::ElementwiseUnaryDescriptor > descriptor)
const armnnSerializer::SpaceToBatchNdDescriptor * descriptor() const
const armnnSerializer::PadDescriptor * descriptor() const
DivisionLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_descriptor(flatbuffers::Offset< armnnSerializer::StackDescriptor > descriptor)
const armnnSerializer::ReduceDescriptor * descriptor() const
void add_strideX(uint32_t strideX)
VT_RECURRENTTOINPUTWEIGHTS
flatbuffers::Offset< RankLayer > CreateRankLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
const armnnSerializer::ConstTensor * mean() const
const armnnSerializer::SwitchLayer * layer_as_SwitchLayer() const
flatbuffers::Offset< StackLayer > Finish()
const armnnSerializer::Convolution3dDescriptor * descriptor() const
flatbuffers::uoffset_t start_
NormalizationDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_padBottom(uint32_t padBottom)
bool layerNormEnabled() const
flatbuffers::Offset< TransposeLayer > CreateTransposeLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::TransposeDescriptor > descriptor=0)
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
void add_strideY(uint32_t strideY)
TransposeConvolution2dDescriptorBuilder Builder
void add_padBottom(uint32_t padBottom)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const armnnSerializer::ReshapeLayer * layer_as_ReshapeLayer() const
DequantizeLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
FloorLayerBuilder Builder
BindableLayerBaseBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::FlatBufferBuilder & fbb_
GatherDescriptorBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
void add_beginMask(int32_t beginMask)
SoftmaxLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::FlatBufferBuilder & fbb_
const char * EnumNamePoolingAlgorithm(PoolingAlgorithm e)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
BatchNormalizationDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< SpaceToDepthDescriptor > Finish()
uint32_t maxDetections() const
flatbuffers::Offset< ComparisonLayer > CreateComparisonLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ComparisonDescriptor > descriptor=0)
flatbuffers::FlatBufferBuilder & fbb_
SwitchLayerBuilder Builder
flatbuffers::Offset< SpaceToBatchNdLayer > Finish()
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::Offset< SwitchLayer > Finish()
void add_projectionEnabled(bool projectionEnabled)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
BatchToSpaceNdDescriptor Table
PermuteLayerBuilder Builder
void add_strideY(uint32_t strideY)
const char * EnumNameConstTensorData(ConstTensorData e)
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
void add_descriptor(flatbuffers::Offset< armnnSerializer::StridedSliceDescriptor > descriptor)
flatbuffers::uoffset_t start_
InstanceNormalizationLayer Table
void add_padList(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> padList)
flatbuffers::Offset< AdditionLayer > Finish()
MaximumLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const char * EnumNameReduceOperation(ReduceOperation e)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
DepthwiseConvolution2dLayer Table
flatbuffers::Offset< ChannelShuffleLayer > Finish()
void add_padTop(uint32_t padTop)
void add_transposeWeightsMatrix(bool transposeWeightsMatrix)
const armnnSerializer::ConstTensor * inputLayerNormWeights() const
FeatureCompatibilityVersions Table
PreluLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
DequantizeLayerBuilder Builder
void add_keepDims(bool keepDims)
const armnnSerializer::ResizeBilinearLayer * layer_as_ResizeBilinearLayer() const
flatbuffers::Offset< ConstTensor > CreateConstTensor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::TensorInfo > info=0, armnnSerializer::ConstTensorData data_type=armnnSerializer::ConstTensorData_NONE, flatbuffers::Offset< void > data=0)
float nmsIouThreshold() const
void add_dilationZ(uint32_t dilationZ)
QLstmLayerBuilder Builder
void add_crops(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> crops)
flatbuffers::Offset< QuantizeLayer > CreateQuantizeLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::DivisionLayer * layer_as_DivisionLayer() const
const armnnSerializer::TransposeDescriptor * descriptor() const
QLstmDescriptorBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
const flatbuffers::Vector< int32_t > * begin() const
void add_biasEnabled(bool biasEnabled)
const armnnSerializer::Pooling2dLayer * layer_as_Pooling2dLayer() const
MeanDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const PaddingMethod(& EnumValuesPaddingMethod())[2]
StridedSliceLayerBuilder Builder
void add_timeMajor(bool timeMajor)
void add_numInputs(uint32_t numInputs)
Convolution2dDescriptor Table
flatbuffers::Offset< InputSlot > CreateInputSlot(flatbuffers::FlatBufferBuilder &_fbb, uint32_t index=0, const armnnSerializer::Connection *connection=0)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
ResizeBilinearLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< SpaceToDepthDescriptor > CreateSpaceToDepthDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t blockSize=0, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
flatbuffers::FlatBufferBuilder & fbb_
armnnSerializer::NormalizationAlgorithmChannel normChannelType() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
ResizeBilinearDescriptorBuilder Builder
MergerLayerBuilder Builder
flatbuffers::Offset< SerializedGraph > Finish()
void FinishSerializedGraphBuffer(flatbuffers::FlatBufferBuilder &fbb, flatbuffers::Offset< armnnSerializer::SerializedGraph > root)
flatbuffers::Offset< QuantizedLstmLayer > CreateQuantizedLstmLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::QuantizedLstmInputParams > inputParams=0)
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
void add_axis(uint32_t axis)
QLstmLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::Offset< TransposeDescriptor > CreateTransposeDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint32_t > *dimMappings=nullptr)
OriginsDescriptorBuilder Builder
int32_t layerBindingId() const
flatbuffers::Offset< ResizeBilinearDescriptor > Finish()
flatbuffers::Offset< TransposeDescriptor > CreateTransposeDescriptor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> dimMappings=0)
DepthwiseConvolution2dLayerBuilder Builder
void add_numDimensions(uint32_t numDimensions)
flatbuffers::uoffset_t start_
const flatbuffers::Vector< int8_t > * data() const
Pooling2dDescriptorBuilder Builder
TensorInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_hiddenStateZeroPoint(int32_t hiddenStateZeroPoint)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const armnnSerializer::LogSoftmaxLayer * layer_as_LogSoftmaxLayer() const
flatbuffers::FlatBufferBuilder & fbb_
void add_gamma(float gamma)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::FlatBufferBuilder & fbb_
armnnSerializer::ComparisonOperation operation() const
void add_cellIntermediateScale(float cellIntermediateScale)
flatbuffers::uoffset_t start_
LstmInputParamsBuilder Builder
const armnnSerializer::ResizeLayer * layer_as_ResizeLayer() const
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
void add_dimensionality(uint32_t dimensionality)
const armnnSerializer::ComparisonLayer * layer_as_ComparisonLayer() const
flatbuffers::uoffset_t start_
SliceLayerBuilder Builder
flatbuffers::Offset< DetectionPostProcessDescriptor > CreateDetectionPostProcessDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t maxDetections=0, uint32_t maxClassesPerDetection=0, uint32_t detectionsPerClass=0, float nmsScoreThreshold=0.0f, float nmsIouThreshold=0.0f, uint32_t numClasses=0, bool useRegularNms=false, float scaleX=0.0f, float scaleY=0.0f, float scaleW=0.0f, float scaleH=0.0f)
flatbuffers::Offset< InstanceNormalizationLayer > Finish()
bool constantWeights() const
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
const OutputShapeRounding(& EnumValuesOutputShapeRounding())[2]
const armnnSerializer::SerializedGraph * GetSerializedGraph(const void *buf)
const char *const * EnumNamesLayerType()
flatbuffers::Offset< Pooling3dLayer > CreatePooling3dLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::Pooling3dDescriptor > descriptor=0)
void add_data(flatbuffers::Offset< flatbuffers::Vector< int64_t >> data)
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::LogicalBinaryDescriptor * descriptor() const
flatbuffers::Offset< AnyLayer > CreateAnyLayer(flatbuffers::FlatBufferBuilder &_fbb, armnnSerializer::Layer layer_type=armnnSerializer::Layer_NONE, flatbuffers::Offset< void > layer=0)
GatherDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
MeanLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< OutputLayer > Finish()
flatbuffers::Offset< DepthwiseConvolution2dLayer > CreateDepthwiseConvolution2dLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::DepthwiseConvolution2dDescriptor > descriptor=0, flatbuffers::Offset< armnnSerializer::ConstTensor > weights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > biases=0)
const char * EnumNameLayer(Layer e)
flatbuffers::Offset< MergeLayer > CreateMergeLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
flatbuffers::Offset< SliceLayer > Finish()
const armnnSerializer::FloorLayer * layer_as_FloorLayer() const
BatchNormalizationDescriptorBuilder Builder
L2NormalizationDescriptorBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
StackDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_padFront(uint32_t padFront)
const armnnSerializer::MultiplicationLayer * layer_as_MultiplicationLayer() const
ChannelShuffleLayer Table
StridedSliceLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
const armnnSerializer::TensorInfo * info() const
const armnnSerializer::SoftmaxDescriptor * descriptor() const
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
EqualLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
ReduceLayerBuilder Builder
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
ResizeDescriptorBuilder Builder
void add_activationFunction(armnnSerializer::ActivationFunction activationFunction)
flatbuffers::Offset< SoftmaxLayer > Finish()
const flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::OutputSlot > > * outputSlots() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::Offset< ActivationDescriptor > Finish()
VT_MAXCLASSESPERDETECTION
bool VerifyConstTensorData(flatbuffers::Verifier &verifier, const void *obj, ConstTensorData type)
const flatbuffers::Vector< uint32_t > * targetShape() const
flatbuffers::Offset< QLstmInputParams > CreateQLstmInputParams(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToForgetWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToCellWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToOutputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToForgetWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToCellWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToOutputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > forgetGateBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > outputGateBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToInputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToInputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputGateBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > projectionWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > projectionBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellToInputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellToForgetWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellToOutputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputLayerNormWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > forgetLayerNormWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellLayerNormWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > outputLayerNormWeights=0)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
flatbuffers::Offset< ResizeLayer > Finish()
const armnnSerializer::ConstTensor * cellToForgetWeights() const
ResizeBilinearDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
flatbuffers::Offset< ReshapeDescriptor > Finish()
const LayerType(& EnumValuesLayerType())[67]
void add_poolWidth(uint32_t poolWidth)
void add_cifgEnabled(bool cifgEnabled)
const flatbuffers::Vector< uint32_t > * axis() const
flatbuffers::Offset< ShortData > Finish()
void add_inputSlots(flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::InputSlot >>> inputSlots)
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
int32_t shrinkAxisMask() const
void add_biasEnabled(bool biasEnabled)
void add_input(flatbuffers::Offset< armnnSerializer::ConstTensor > input)
const armnnSerializer::LayerBase * base() const
flatbuffers::Offset< TensorInfo > CreateTensorInfo(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> dimensions=0, armnnSerializer::DataType dataType=armnnSerializer::DataType_Float16, float quantizationScale=1.0f, int32_t quantizationOffset=0, flatbuffers::Offset< flatbuffers::Vector< float >> quantizationScales=0, uint32_t quantizationDim=0, uint32_t dimensionality=1, flatbuffers::Offset< flatbuffers::Vector< uint8_t >> dimensionSpecificity=0, bool isConstant=false)
flatbuffers::uoffset_t start_
bool Verify(flatbuffers::Verifier &verifier) const
flatbuffers::FlatBufferBuilder & fbb_
Convolution2dLayerBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
void add_paddingMethod(armnnSerializer::PaddingMethod paddingMethod)
flatbuffers::Offset< ConstantLayer > Finish()
VT_RECURRENTTOOUTPUTWEIGHTS
flatbuffers::uoffset_t start_
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
flatbuffers::Offset< SpaceToBatchNdDescriptor > CreateSpaceToBatchNdDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint32_t > *blockShape=nullptr, const std::vector< uint32_t > *padList=nullptr, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::BindableLayerBase * base() const
const char *const * EnumNamesOutputShapeRounding()
flatbuffers::Offset< FullyConnectedDescriptor > CreateFullyConnectedDescriptor(flatbuffers::FlatBufferBuilder &_fbb, bool biasEnabled=false, bool transposeWeightsMatrix=false, bool constantWeights=true)
flatbuffers::Offset< ElementwiseUnaryLayer > Finish()
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< ComparisonLayer > Finish()
flatbuffers::Offset< TransposeConvolution2dLayer > CreateTransposeConvolution2dLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::TransposeConvolution2dDescriptor > descriptor=0, flatbuffers::Offset< armnnSerializer::ConstTensor > weights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > biases=0)
flatbuffers::Offset< MinimumLayer > Finish()
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
void add_index(uint32_t index)
const armnnSerializer::ActivationLayer * layer_as_ActivationLayer() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const armnnSerializer::DequantizeLayer * layer_as_DequantizeLayer() const
Pooling2dDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
void add_constantTensorsAsInputs(uint32_t constantTensorsAsInputs)
void add_data(flatbuffers::Offset< flatbuffers::Vector< int32_t >> data)
flatbuffers::FlatBufferBuilder & fbb_
const ArgMinMaxFunction(& EnumValuesArgMinMaxFunction())[2]
const armnnSerializer::StandInLayer * layer_as_StandInLayer() const
flatbuffers::Offset< PreluLayer > CreatePreluLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
NormalizationLayerBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
Convolution3dDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_outputIntermediateScale(float outputIntermediateScale)
void add_strideY(uint32_t strideY)
IntDataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
float clippingThresCell() const
const armnnSerializer::BatchToSpaceNdLayer * layer_as_BatchToSpaceNdLayer() const
flatbuffers::Offset< StandInDescriptor > Finish()
bool transposeWeightsMatrix() const
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
uint32_t blockSize() const
void add_padTop(uint32_t padTop)
flatbuffers::Offset< StandInDescriptor > CreateStandInDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t numInputs=0, uint32_t numOutputs=0)
const armnnSerializer::ConstTensor * variance() const
const armnnSerializer::Pooling2dDescriptor * Pooling2dDescriptor
flatbuffers::Offset< NormalizationLayer > Finish()
flatbuffers::Offset< PreluLayer > Finish()
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Connection FLATBUFFERS_FINAL_CLASS
void add_dimMappings(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> dimMappings)
flatbuffers::Offset< ByteData > Finish()
void add_weightsLayoutScheme(uint32_t weightsLayoutScheme)
void add_padTop(uint32_t padTop)
void add_beta(float beta)
flatbuffers::FlatBufferBuilder & fbb_
TransposeConvolution2dDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< TransposeLayer > Finish()
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< GreaterLayer > Finish()
LogSoftmaxLayerBuilder Builder
flatbuffers::Offset< Convolution3dLayer > Finish()
void add_descriptor(flatbuffers::Offset< armnnSerializer::ReduceDescriptor > descriptor)
flatbuffers::FlatBufferBuilder & fbb_
void add_targetHeight(uint32_t targetHeight)
void add_quantizationScales(flatbuffers::Offset< flatbuffers::Vector< float >> quantizationScales)
flatbuffers::Offset< QLstmLayer > Finish()
const armnnSerializer::ArgMinMaxLayer * layer_as_ArgMinMaxLayer() const
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
flatbuffers::Offset< MultiplicationLayer > CreateMultiplicationLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
SpaceToDepthDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_cellClip(float cellClip)
flatbuffers::Offset< DepthToSpaceLayer > CreateDepthToSpaceLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::DepthToSpaceDescriptor > descriptor=0)
void add_strideX(uint32_t strideX)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< InstanceNormalizationLayer > CreateInstanceNormalizationLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::InstanceNormalizationDescriptor > descriptor=0)
flatbuffers::Offset< ReduceLayer > Finish()
const armnnSerializer::Pooling3dLayer * layer_as_Pooling3dLayer() const
flatbuffers::uoffset_t start_
const PaddingMode(& EnumValuesPaddingMode())[3]
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_strideZ(uint32_t strideZ)
QuantizedLstmLayerBuilder Builder
const armnnSerializer::Pooling3dDescriptor * descriptor() const
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::DepthwiseConvolution2dDescriptor * descriptor() const
uint32_t concatAxis() const
ResizeBilinearLayer Table
flatbuffers::uoffset_t start_
flatbuffers::Offset< SliceLayer > CreateSliceLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::SliceDescriptor > descriptor=0)
void add_padBottom(uint32_t padBottom)
armnnSerializer::UnaryOperation operation() const
void add_numOutputs(uint32_t numOutputs)
flatbuffers::FlatBufferBuilder & fbb_
void add_end(flatbuffers::Offset< flatbuffers::Vector< int32_t >> end)
void add_biases(flatbuffers::Offset< armnnSerializer::ConstTensor > biases)
flatbuffers::Offset< TensorInfo > CreateTensorInfoDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint32_t > *dimensions=nullptr, armnnSerializer::DataType dataType=armnnSerializer::DataType_Float16, float quantizationScale=1.0f, int32_t quantizationOffset=0, const std::vector< float > *quantizationScales=nullptr, uint32_t quantizationDim=0, uint32_t dimensionality=1, const std::vector< uint8_t > *dimensionSpecificity=nullptr, bool isConstant=false)
flatbuffers::uoffset_t start_
void add_axis(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> axis)
flatbuffers::Offset< Convolution2dDescriptor > CreateConvolution2dDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t padLeft=0, uint32_t padRight=0, uint32_t padTop=0, uint32_t padBottom=0, uint32_t strideX=0, uint32_t strideY=0, uint32_t dilationX=1, uint32_t dilationY=1, bool biasEnabled=false, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NCHW)
flatbuffers::Offset< PadDescriptor > CreatePadDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint32_t > *padList=nullptr, float padValue=0.0f, armnnSerializer::PaddingMode paddingMode=armnnSerializer::PaddingMode_Constant)
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
flatbuffers::Offset< BatchNormalizationDescriptor > Finish()
StandInDescriptorBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< Pooling3dDescriptor > CreatePooling3dDescriptor(flatbuffers::FlatBufferBuilder &_fbb, armnnSerializer::PoolingAlgorithm poolType=armnnSerializer::PoolingAlgorithm_Max, uint32_t padLeft=0, uint32_t padRight=0, uint32_t padTop=0, uint32_t padBottom=0, uint32_t padFront=0, uint32_t padBack=0, uint32_t poolWidth=0, uint32_t poolHeight=0, uint32_t poolDepth=0, uint32_t strideX=0, uint32_t strideY=0, uint32_t strideZ=0, armnnSerializer::OutputShapeRounding outputShapeRounding=armnnSerializer::OutputShapeRounding_Floor, armnnSerializer::PaddingMethod paddingMethod=armnnSerializer::PaddingMethod_IgnoreValue, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
const char *const * EnumNamesLayer()
void add_biases(flatbuffers::Offset< armnnSerializer::ConstTensor > biases)
flatbuffers::Offset< InputLayer > CreateInputLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::BindableLayerBase > base=0)
void add_axis(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> axis)
Convolution2dDescriptorBuilder Builder
TransposeDescriptor Table
DepthToSpaceDescriptor Table
const armnnSerializer::NormalizationDescriptor * descriptor() const
flatbuffers::Offset< Pooling3dLayer > Finish()
void add_scaleY(float scaleY)
void add_dataType(armnnSerializer::DataType dataType)
const char * SerializedGraphIdentifier()
Pooling3dDescriptorBuilder Builder
bool halfPixelCenters() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::Offset< MultiplicationLayer > Finish()
uint32_t dilationX() const
AdditionLayerBuilder Builder
float clippingThresProj() const
const armnnSerializer::LstmDescriptor * descriptor() const
flatbuffers::Offset< ShortData > CreateShortData(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< int16_t >> data=0)
FullyConnectedDescriptorBuilder Builder
void add_outputSlots(flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::OutputSlot >>> outputSlots)
flatbuffers::Offset< ConcatLayer > CreateConcatLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::OriginsDescriptor > descriptor=0)
flatbuffers::Offset< FillDescriptor > Finish()
flatbuffers::Offset< IntData > Finish()
SpaceToDepthLayerBuilder Builder
const armnnSerializer::ConstTensor * biases() const
Convolution2dDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
DivisionLayerBuilder Builder
ArgMinMaxLayerBuilder Builder
ComparisonDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
const flatbuffers::Vector< uint8_t > * dimensionSpecificity() const
flatbuffers::Offset< LstmDescriptor > Finish()
PreluLayerBuilder Builder
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const armnnSerializer::ReduceLayer * layer_as_ReduceLayer() const
armnnSerializer::PaddingMode paddingMode() const
VT_RECURRENTTOFORGETWEIGHTS
flatbuffers::uoffset_t start_
void add_stride(flatbuffers::Offset< flatbuffers::Vector< int32_t >> stride)
SoftmaxLayerBuilder Builder
void add_axis(uint32_t axis)
bool VerifySizePrefixedSerializedGraphBuffer(flatbuffers::Verifier &verifier)
flatbuffers::FlatBufferBuilder & fbb_
LogicalBinaryDescriptor Table
flatbuffers::Offset< SubtractionLayer > CreateSubtractionLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
void add_cifgEnabled(bool cifgEnabled)
void add_descriptor(flatbuffers::Offset< armnnSerializer::SoftmaxDescriptor > descriptor)
flatbuffers::Offset< EqualLayer > Finish()
flatbuffers::Offset< BindableLayerBase > CreateBindableLayerBase(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, int32_t layerBindingId=0)
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< NormalizationDescriptor > Finish()
QLstmDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const flatbuffers::String * layerName() const
flatbuffers::FlatBufferBuilder & fbb_
ConstantLayerBuilder Builder
uint32_t normSize() const
armnnSerializer::DataLayout dataLayout() const
void add_descriptor(flatbuffers::Offset< armnnSerializer::Convolution3dDescriptor > descriptor)
const armnnSerializer::TransposeConvolution2dLayer * layer_as_TransposeConvolution2dLayer() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::FlatBufferBuilder & fbb_
void add_normChannelType(armnnSerializer::NormalizationAlgorithmChannel normChannelType)
flatbuffers::Offset< ArgMinMaxLayer > CreateArgMinMaxLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ArgMinMaxDescriptor > descriptor=0)
void add_descriptor(flatbuffers::Offset< armnnSerializer::ReshapeDescriptor > descriptor)
const armnnSerializer::BatchToSpaceNdDescriptor * descriptor() const
void add_blockShape(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> blockShape)
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::BatchNormalizationLayer * layer_as_BatchNormalizationLayer() const
const flatbuffers::Vector< uint32_t > * size() const
flatbuffers::uoffset_t start_
flatbuffers::Offset< DepthwiseConvolution2dDescriptor > Finish()
const armnnSerializer::ConstTensor * projectionBias() const
flatbuffers::uoffset_t start_
TransposeConvolution2dLayer Table
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
const armnnSerializer::GreaterLayer * layer_as_GreaterLayer() const
flatbuffers::Offset< LayerBase > Finish()
const flatbuffers::Vector< int32_t > * inputIds() const
flatbuffers::Offset< AbsLayer > Finish()
void add_maxDetections(uint32_t maxDetections)
void add_inputIds(flatbuffers::Offset< flatbuffers::Vector< int32_t >> inputIds)
void add_padRight(uint32_t padRight)
flatbuffers::uoffset_t start_
armnnSerializer::ActivationFunction activationFunction() const
const armnnSerializer::ConstTensor * cellToInputWeights() const
void add_axis(int32_t axis)
void add_inputIntermediateScale(float inputIntermediateScale)
void add_dimMappings(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> dimMappings)
FullyConnectedLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
void add_padLeft(uint32_t padLeft)
flatbuffers::Offset< QLstmDescriptor > CreateQLstmDescriptor(flatbuffers::FlatBufferBuilder &_fbb, bool cifgEnabled=true, bool peepholeEnabled=false, bool projectionEnabled=false, bool layerNormEnabled=false, float cellClip=0.0f, float projectionClip=0.0f, float inputIntermediateScale=0.0f, float forgetIntermediateScale=0.0f, float cellIntermediateScale=0.0f, float outputIntermediateScale=0.0f, int32_t hiddenStateZeroPoint=0, float hiddenStateScale=0.0f)
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
NormalizationLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_biasEnabled(bool biasEnabled)
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< GreaterLayer > CreateGreaterLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
void add_clippingThresProj(float clippingThresProj)
void add_alpha(float alpha)
flatbuffers::Offset< SpaceToDepthLayer > Finish()
BatchNormalizationLayer Table
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_descriptor(flatbuffers::Offset< armnnSerializer::Pooling2dDescriptor > descriptor)
void add_inputParams(flatbuffers::Offset< armnnSerializer::QuantizedLstmInputParams > inputParams)
StackDescriptorBuilder Builder
uint32_t poolHeight() const
flatbuffers::uoffset_t start_
const armnnSerializer::StridedSliceLayer * layer_as_StridedSliceLayer() const
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
void add_forgetIntermediateScale(float forgetIntermediateScale)
flatbuffers::Offset< ReshapeLayer > CreateReshapeLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ReshapeDescriptor > descriptor=0)
const char * EnumNameActivationFunction(ActivationFunction e)
void add_inputParams(flatbuffers::Offset< armnnSerializer::QLstmInputParams > inputParams)
flatbuffers::Offset< MeanDescriptor > CreateMeanDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint32_t > *axis=nullptr, bool keepDims=false)
armnnSerializer::OutputShapeRounding outputShapeRounding() const
flatbuffers::Offset< ArgMinMaxDescriptor > CreateArgMinMaxDescriptor(flatbuffers::FlatBufferBuilder &_fbb, armnnSerializer::ArgMinMaxFunction argMinMaxFunction=armnnSerializer::ArgMinMaxFunction_Min, int32_t axis=0)
void add_descriptor(flatbuffers::Offset< armnnSerializer::UnidirectionalSequenceLstmDescriptor > descriptor)
flatbuffers::Offset< SoftmaxDescriptor > CreateSoftmaxDescriptor(flatbuffers::FlatBufferBuilder &_fbb, float beta=0.0f, int32_t axis=-1)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
const armnnSerializer::MergerLayer * layer_as_MergerLayer() const
flatbuffers::Offset< AdditionLayer > CreateAdditionLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
flatbuffers::uoffset_t start_
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
FullyConnectedDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_begin(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> begin)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
EqualLayerBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
void add_strideX(uint32_t strideX)
const armnnSerializer::BatchNormalizationDescriptor * descriptor() const
NormalizationDescriptor Table
flatbuffers::Offset< L2NormalizationDescriptor > CreateL2NormalizationDescriptor(flatbuffers::FlatBufferBuilder &_fbb, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NCHW, float eps=1e-12f)
void add_blockSize(uint32_t blockSize)
void add_paddingMode(armnnSerializer::PaddingMode paddingMode)
OutputLayerBuilder Builder
MultiplicationLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
SliceLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const char * EnumNameNormalizationAlgorithmMethod(NormalizationAlgorithmMethod e)
const armnnSerializer::ResizeDescriptor * descriptor() const
void add_biases(flatbuffers::Offset< armnnSerializer::ConstTensor > biases)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< MinimumLayer > CreateMinimumLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
const char *const * EnumNamesDataType()
StridedSliceDescriptor Table
void add_clippingThresCell(float clippingThresCell)
ReshapeDescriptorBuilder Builder
flatbuffers::Offset< ByteData > CreateByteData(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< int8_t >> data=0)
QuantizedLstmInputParamsBuilder Builder
flatbuffers::Offset< RsqrtLayer > Finish()
const armnnSerializer::ActivationDescriptor * descriptor() const
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< FeatureCompatibilityVersions > CreateFeatureCompatibilityVersions(flatbuffers::FlatBufferBuilder &_fbb, uint32_t bindingIdsScheme=0, uint32_t weightsLayoutScheme=0, uint32_t constantTensorsAsInputs=0)
const armnnSerializer::ConstTensor * inputToInputWeights() const
ChannelShuffleLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
const armnnSerializer::ConstantLayer * layer_as_ConstantLayer() const
flatbuffers::Offset< DepthToSpaceDescriptor > CreateDepthToSpaceDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t blockSize=0, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
void add_padList(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> padList)
UnidirectionalSequenceLstmLayer Table
DetectionPostProcessDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const char * EnumNamePaddingMode(PaddingMode e)
const armnnSerializer::DepthToSpaceDescriptor * descriptor() const
MaximumLayerBuilder Builder
flatbuffers::uoffset_t start_
PadDescriptorBuilder Builder
CastLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::ConstTensor * projectionWeights() const
void add_outputShapeRounding(armnnSerializer::OutputShapeRounding outputShapeRounding)
Convolution3dDescriptor Table
FillDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< LstmInputParams > CreateLstmInputParams(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToForgetWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToCellWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToOutputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToForgetWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToCellWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToOutputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > forgetGateBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > outputGateBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToInputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToInputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellToInputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputGateBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > projectionWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > projectionBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellToForgetWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellToOutputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputLayerNormWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > forgetLayerNormWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellLayerNormWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > outputLayerNormWeights=0)
const void * layer() const
uint32_t weightsLayoutScheme() const
const LogicalBinaryOperation(& EnumValuesLogicalBinaryOperation())[2]
const flatbuffers::Vector< int32_t > * stride() const
flatbuffers::uoffset_t start_
const ResizeMethod(& EnumValuesResizeMethod())[2]
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
PermuteDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< CastLayer > CreateCastLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
flatbuffers::uoffset_t start_
void add_variance(flatbuffers::Offset< armnnSerializer::ConstTensor > variance)
flatbuffers::Offset< LayerBase > CreateLayerBase(flatbuffers::FlatBufferBuilder &_fbb, uint32_t index=0, flatbuffers::Offset< flatbuffers::String > layerName=0, armnnSerializer::LayerType layerType=armnnSerializer::LayerType_Addition, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::InputSlot >>> inputSlots=0, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::OutputSlot >>> outputSlots=0)
flatbuffers::uoffset_t start_
flatbuffers::Offset< ShapeLayer > CreateShapeLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
void add_descriptor(flatbuffers::Offset< armnnSerializer::L2NormalizationDescriptor > descriptor)
const char *const * EnumNamesConstTensorData()
void add_argMinMaxFunction(armnnSerializer::ArgMinMaxFunction argMinMaxFunction)
flatbuffers::Offset< QuantizeLayer > Finish()
const ActivationFunction(& EnumValuesActivationFunction())[12]
const armnnSerializer::QuantizedLstmInputParams * inputParams() const
flatbuffers::Offset< LogSoftmaxDescriptor > Finish()
const char *const * EnumNamesNormalizationAlgorithmMethod()
MergeLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::InstanceNormalizationLayer * layer_as_InstanceNormalizationLayer() const
void add_dilationX(uint32_t dilationX)
const armnnSerializer::QuantizedLstmLayer * layer_as_QuantizedLstmLayer() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::Offset< QuantizedLstmInputParams > CreateQuantizedLstmInputParams(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToInputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToForgetWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToCellWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToOutputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToInputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToForgetWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToCellWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToOutputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputGateBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > forgetGateBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > outputGateBias=0)
void add_descriptor(flatbuffers::Offset< armnnSerializer::Pooling3dDescriptor > descriptor)
flatbuffers::Offset< ReduceDescriptor > CreateReduceDescriptor(flatbuffers::FlatBufferBuilder &_fbb, bool keepDims=false, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> axis=0, armnnSerializer::ReduceOperation reduceOperation=armnnSerializer::ReduceOperation_Sum)
flatbuffers::Offset< StackDescriptor > CreateStackDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t axis=0, uint32_t numInputs=0, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> inputShape=0)
flatbuffers::Offset< BatchToSpaceNdDescriptor > CreateBatchToSpaceNdDescriptor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> blockShape=0, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> crops=0, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
flatbuffers::uoffset_t start_
const flatbuffers::Vector< uint32_t > * dimensions() const
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::ReshapeDescriptor * descriptor() const
DepthwiseConvolution2dDescriptor Table
flatbuffers::FlatBufferBuilder & fbb_
void add_inputShape(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> inputShape)
LogicalBinaryLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
QuantizeLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_padRight(uint32_t padRight)
PermuteDescriptorBuilder Builder
LayerBaseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
DepthToSpaceLayerBuilder Builder
const DataLayout(& EnumValuesDataLayout())[4]
flatbuffers::Offset< ResizeDescriptor > Finish()
DepthwiseConvolution2dLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< SplitterLayer > CreateSplitterLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ViewsDescriptor > descriptor=0)
flatbuffers::FlatBufferBuilder & fbb_
ComparisonDescriptorBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
void add_viewOrigins(flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::UintVector >>> viewOrigins)
void add_gamma(flatbuffers::Offset< armnnSerializer::ConstTensor > gamma)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_shrinkAxisMask(int32_t shrinkAxisMask)
flatbuffers::FlatBufferBuilder & fbb_
OriginsDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_peepholeEnabled(bool peepholeEnabled)
SerializedGraphBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< OutputLayer > CreateOutputLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::BindableLayerBase > base=0)
void add_descriptor(flatbuffers::Offset< armnnSerializer::InstanceNormalizationDescriptor > descriptor)
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
flatbuffers::uoffset_t start_
const armnnSerializer::ChannelShuffleDescriptor * descriptor() const
void add_bindingIdsScheme(uint32_t bindingIdsScheme)
flatbuffers::Offset< BatchToSpaceNdLayer > Finish()
StridedSliceDescriptorBuilder Builder
flatbuffers::Offset< SoftmaxLayer > CreateSoftmaxLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::SoftmaxDescriptor > descriptor=0)
void add_descriptor(flatbuffers::Offset< armnnSerializer::LogSoftmaxDescriptor > descriptor)
flatbuffers::Offset< FillDescriptor > CreateFillDescriptor(flatbuffers::FlatBufferBuilder &_fbb, float value=0.0f)
void add_poolType(armnnSerializer::PoolingAlgorithm poolType)
flatbuffers::Offset< ConstTensor > Finish()
flatbuffers::FlatBufferBuilder & fbb_
armnnSerializer::ResizeMethod method() const
const armnnSerializer::Convolution3dLayer * layer_as_Convolution3dLayer() const
const flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::UintVector > > * viewOrigins() const
void add_strideX(uint32_t strideX)
FeatureCompatibilityVersionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
TensorInfoBuilder Builder
void add_inputParams(flatbuffers::Offset< armnnSerializer::LstmInputParams > inputParams)
void add_descriptor(flatbuffers::Offset< armnnSerializer::TransposeConvolution2dDescriptor > descriptor)
flatbuffers::Offset< StridedSliceLayer > CreateStridedSliceLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::StridedSliceDescriptor > descriptor=0)
flatbuffers::uoffset_t start_
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
BatchNormalizationLayerBuilder Builder
flatbuffers::Offset< LogSoftmaxDescriptor > CreateLogSoftmaxDescriptor(flatbuffers::FlatBufferBuilder &_fbb, float beta=1.0f, int32_t axis=-1)
flatbuffers::Offset< SoftmaxDescriptor > Finish()
ResizeBilinearDescriptor Table
flatbuffers::FlatBufferBuilder & fbb_
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::FlatBufferBuilder & fbb_
uint32_t dimensionality() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::PadLayer * layer_as_PadLayer() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::Offset< SliceDescriptor > CreateSliceDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint32_t > *begin=nullptr, const std::vector< uint32_t > *size=nullptr)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_padLeft(uint32_t padLeft)
OutputSlotBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_descriptor(flatbuffers::Offset< armnnSerializer::FillDescriptor > descriptor)
const char *const * EnumNamesNormalizationAlgorithmChannel()
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
LstmDescriptor UnidirectionalSequenceLstmDescriptor
void add_descriptor(flatbuffers::Offset< armnnSerializer::ChannelShuffleDescriptor > descriptor)
DepthToSpaceLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
void add_padBack(uint32_t padBack)
const ComparisonOperation(& EnumValuesComparisonOperation())[6]
flatbuffers::Offset< RsqrtLayer > CreateRsqrtLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
void add_data(flatbuffers::Offset< flatbuffers::Vector< int8_t >> data)
void add_dilationY(uint32_t dilationY)
const flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::UintVector > > * viewSizes() const
void add_axis(int32_t axis)
const armnnSerializer::DepthwiseConvolution2dLayer * layer_as_DepthwiseConvolution2dLayer() const
void add_padRight(uint32_t padRight)
flatbuffers::Offset< FullyConnectedLayer > Finish()
void add_descriptor(flatbuffers::Offset< armnnSerializer::ComparisonDescriptor > descriptor)
flatbuffers::Offset< MeanLayer > CreateMeanLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::MeanDescriptor > descriptor=0)
flatbuffers::Offset< L2NormalizationLayer > Finish()
StridedSliceDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
uint32_t activationFunc() const
DepthToSpaceDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
VT_FORGETINTERMEDIATESCALE
const flatbuffers::Vector< uint32_t > * inputShape() const
uint32_t poolWidth() const
void add_dilationY(uint32_t dilationY)
flatbuffers::Offset< DetectionPostProcessLayer > Finish()
void add_blockShape(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> blockShape)
const armnnSerializer::L2NormalizationDescriptor * descriptor() const
flatbuffers::Offset< ActivationLayer > CreateActivationLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ActivationDescriptor > descriptor=0)
flatbuffers::Offset< SpaceToDepthLayer > CreateSpaceToDepthLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::SpaceToDepthDescriptor > descriptor=0)
flatbuffers::FlatBufferBuilder & fbb_
ElementwiseUnaryLayerBuilder Builder
flatbuffers::Offset< SliceDescriptor > CreateSliceDescriptor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> begin=0, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> size=0)
const armnnSerializer::OriginsDescriptor * origins() const
flatbuffers::uoffset_t start_
TransposeConvolution2dLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
GreaterLayerBuilder Builder
LstmDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
bool useRegularNms() const
flatbuffers::Offset< BatchNormalizationLayer > CreateBatchNormalizationLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::BatchNormalizationDescriptor > descriptor=0, flatbuffers::Offset< armnnSerializer::ConstTensor > mean=0, flatbuffers::Offset< armnnSerializer::ConstTensor > variance=0, flatbuffers::Offset< armnnSerializer::ConstTensor > beta=0, flatbuffers::Offset< armnnSerializer::ConstTensor > gamma=0)
DepthwiseConvolution2dDescriptorBuilder Builder
flatbuffers::Offset< BatchNormalizationDescriptor > CreateBatchNormalizationDescriptor(flatbuffers::FlatBufferBuilder &_fbb, float eps=0.0f, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
ResizeLayerBuilder Builder
flatbuffers::uoffset_t start_
void add_strideX(uint32_t strideX)
const flatbuffers::Vector< int32_t > * outputIds() const
flatbuffers::uoffset_t start_
flatbuffers::Offset< Pooling2dLayer > Finish()
flatbuffers::Offset< ChannelShuffleDescriptor > Finish()
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::Offset< GatherDescriptor > CreateGatherDescriptor(flatbuffers::FlatBufferBuilder &_fbb, int32_t axis=0)
const armnnSerializer::FullyConnectedLayer * layer_as_FullyConnectedLayer() const
flatbuffers::Offset< FillLayer > Finish()
flatbuffers::Offset< Convolution3dLayer > CreateConvolution3dLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::Convolution3dDescriptor > descriptor=0)
flatbuffers::Offset< ActivationDescriptor > CreateActivationDescriptor(flatbuffers::FlatBufferBuilder &_fbb, armnnSerializer::ActivationFunction activationFunction=armnnSerializer::ActivationFunction_Sigmoid, float a=0.0f, float b=0.0f)
void add_descriptor(flatbuffers::Offset< armnnSerializer::ViewsDescriptor > descriptor)
const armnnSerializer::StridedSliceDescriptor * descriptor() const
flatbuffers::uoffset_t start_
flatbuffers::Offset< NormalizationLayer > CreateNormalizationLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::NormalizationDescriptor > descriptor=0)
flatbuffers::Offset< OriginsDescriptor > Finish()
L2NormalizationLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
void add_concatAxis(uint32_t concatAxis)
ReshapeLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::ChannelShuffleLayer * layer_as_ChannelShuffleLayer() const
FeatureCompatibilityVersionsBuilder Builder
flatbuffers::Offset< AnyLayer > Finish()
const char *const * EnumNamesComparisonOperation()
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< ViewsDescriptor > CreateViewsDescriptor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::OriginsDescriptor > origins=0, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::UintVector >>> viewSizes=0)
void add_poolHeight(uint32_t poolHeight)
void add_cifgEnabled(bool cifgEnabled)
flatbuffers::Offset< PermuteDescriptor > CreatePermuteDescriptor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> dimMappings=0)
void add_projectionClip(float projectionClip)
bool peepholeEnabled() const
flatbuffers::uoffset_t start_
const armnnSerializer::TensorInfo * tensorInfo() const
SerializedGraphBuilder Builder
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_strideY(uint32_t strideY)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< SubtractionLayer > Finish()
flatbuffers::Offset< MeanDescriptor > CreateMeanDescriptor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> axis=0, bool keepDims=false)
flatbuffers::FlatBufferBuilder & fbb_
ReduceDescriptorBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
BatchToSpaceNdLayer Table
flatbuffers::Offset< StandInLayer > CreateStandInLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::StandInDescriptor > descriptor=0)
flatbuffers::uoffset_t start_
const armnnSerializer::Pooling2dDescriptor * descriptor() const
void add_padTop(uint32_t padTop)
flatbuffers::FlatBufferBuilder & fbb_
const char * EnumNameResizeMethod(ResizeMethod e)
const armnnSerializer::ConstTensor * forgetGateBias() const
void add_keepDims(bool keepDims)
void add_layerBindingId(int32_t layerBindingId)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_scaleX(float scaleX)
DetectionPostProcessDescriptorBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< ReduceDescriptor > Finish()
SpaceToDepthDescriptorBuilder Builder
const armnnSerializer::Convolution2dDescriptor * descriptor() const
void add_descriptor(flatbuffers::Offset< armnnSerializer::ResizeDescriptor > descriptor)
ChannelShuffleLayerBuilder Builder
void add_outputIds(flatbuffers::Offset< flatbuffers::Vector< int32_t >> outputIds)
void add_operation(armnnSerializer::LogicalBinaryOperation operation)
void add_mean(flatbuffers::Offset< armnnSerializer::ConstTensor > mean)
flatbuffers::Offset< UintVector > Finish()
ActivationDescriptor Table
const armnnSerializer::IntData * data_as_IntData() const
flatbuffers::Offset< StandInLayer > Finish()
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
const armnnSerializer::LogicalBinaryLayer * layer_as_LogicalBinaryLayer() const
float outputIntermediateScale() const
void add_padBack(uint32_t padBack)
GreaterLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::ConstTensor * cellToOutputWeights() const
flatbuffers::uoffset_t start_
flatbuffers::Offset< StridedSliceDescriptor > Finish()
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::ConstTensor * inputToForgetWeights() const
flatbuffers::Offset< Convolution3dDescriptor > Finish()
flatbuffers::Offset< DetectionPostProcessDescriptor > Finish()
flatbuffers::Offset< SwitchLayer > CreateSwitchLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
const armnnSerializer::InputLayer * layer_as_InputLayer() const
uint32_t numOutputs() const
flatbuffers::FlatBufferBuilder & fbb_
VT_RECURRENTTOCELLWEIGHTS
flatbuffers::FlatBufferBuilder & fbb_
const NormalizationAlgorithmMethod(& EnumValuesNormalizationAlgorithmMethod())[2]
flatbuffers::uoffset_t start_
float quantizationScale() const
flatbuffers::Offset< UintVector > CreateUintVectorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint32_t > *data=nullptr)
flatbuffers::Offset< ResizeBilinearDescriptor > CreateResizeBilinearDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t targetWidth=0, uint32_t targetHeight=0, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC, bool alignCorners=false, bool halfPixelCenters=false)
const ConstTensorData(& EnumValuesConstTensorData())[5]
const armnnSerializer::QLstmInputParams * inputParams() const
void add_layerName(flatbuffers::Offset< flatbuffers::String > layerName)
uint32_t numViews() const
const armnnSerializer::GatherLayer * layer_as_GatherLayer() const
L2NormalizationDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< ElementwiseUnaryDescriptor > CreateElementwiseUnaryDescriptor(flatbuffers::FlatBufferBuilder &_fbb, armnnSerializer::UnaryOperation operation=armnnSerializer::UnaryOperation_Abs)
void add_padLeft(uint32_t padLeft)
void add_size(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> size)
void add_padBottom(uint32_t padBottom)
flatbuffers::Offset< Pooling3dDescriptor > Finish()
flatbuffers::uoffset_t start_
flatbuffers::Offset< ReshapeDescriptor > CreateReshapeDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint32_t > *targetShape=nullptr)
const armnnSerializer::SplitterLayer * layer_as_SplitterLayer() const
void add_nmsScoreThreshold(float nmsScoreThreshold)
flatbuffers::uoffset_t start_
void add_padValue(float padValue)
SplitterLayerBuilder Builder
flatbuffers::Offset< BatchNormalizationLayer > Finish()
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
ActivationLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
uint32_t poolDepth() const
flatbuffers::FlatBufferBuilder & fbb_
const char * EnumNameArgMinMaxFunction(ArgMinMaxFunction e)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< Convolution2dDescriptor > Finish()
flatbuffers::Offset< PadDescriptor > CreatePadDescriptor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> padList=0, float padValue=0.0f, armnnSerializer::PaddingMode paddingMode=armnnSerializer::PaddingMode_Constant)
const armnnSerializer::QLstmLayer * layer_as_QLstmLayer() const
void add_useRegularNms(bool useRegularNms)
const armnnSerializer::SpaceToBatchNdLayer * layer_as_SpaceToBatchNdLayer() const
void add_descriptor(flatbuffers::Offset< armnnSerializer::QLstmDescriptor > descriptor)
flatbuffers::Offset< TransposeConvolution2dDescriptor > Finish()
const PoolingAlgorithm(& EnumValuesPoolingAlgorithm())[3]
flatbuffers::Offset< PadLayer > CreatePadLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::PadDescriptor > descriptor=0)
flatbuffers::Offset< FloorLayer > CreateFloorLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
flatbuffers::uoffset_t start_
void add_descriptor(flatbuffers::Offset< armnnSerializer::DepthwiseConvolution2dDescriptor > descriptor)
flatbuffers::Offset< DivisionLayer > Finish()
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_projectionEnabled(bool projectionEnabled)
ComparisonLayerBuilder Builder
uint32_t bindingIdsScheme() const
DetectionPostProcessLayerBuilder Builder
flatbuffers::Offset< NormalizationDescriptor > CreateNormalizationDescriptor(flatbuffers::FlatBufferBuilder &_fbb, armnnSerializer::NormalizationAlgorithmChannel normChannelType=armnnSerializer::NormalizationAlgorithmChannel_Across, armnnSerializer::NormalizationAlgorithmMethod normMethodType=armnnSerializer::NormalizationAlgorithmMethod_LocalBrightness, uint32_t normSize=0, float alpha=0.0f, float beta=0.0f, float k=0.0f, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NCHW)
RankLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::PermuteDescriptor * descriptor() const
uint32_t constantTensorsAsInputs() const
const armnnSerializer::ConstTensor * recurrentToCellWeights() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::uoffset_t start_
FillLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
flatbuffers::Offset< Pooling2dDescriptor > CreatePooling2dDescriptor(flatbuffers::FlatBufferBuilder &_fbb, armnnSerializer::PoolingAlgorithm poolType=armnnSerializer::PoolingAlgorithm_Max, uint32_t padLeft=0, uint32_t padRight=0, uint32_t padTop=0, uint32_t padBottom=0, uint32_t poolWidth=0, uint32_t poolHeight=0, uint32_t strideX=0, uint32_t strideY=0, armnnSerializer::OutputShapeRounding outputShapeRounding=armnnSerializer::OutputShapeRounding_Floor, armnnSerializer::PaddingMethod paddingMethod=armnnSerializer::PaddingMethod_IgnoreValue, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
QLstmInputParamsBuilder Builder
void add_descriptor(flatbuffers::Offset< armnnSerializer::DepthToSpaceDescriptor > descriptor)
SoftmaxDescriptor LogSoftmaxDescriptor
A LogSoftmaxDescriptor for the LogSoftmaxLayer.
flatbuffers::uoffset_t start_
void add_newAxisMask(int32_t newAxisMask)
void add_padBottom(uint32_t padBottom)
flatbuffers::Offset< EqualLayer > CreateEqualLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
LogicalBinaryDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_quantizationDim(uint32_t quantizationDim)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const armnnSerializer::ConstTensor * recurrentToInputWeights() const
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
flatbuffers::Offset< ConstantLayer > CreateConstantLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ConstTensor > input=0)
flatbuffers::Offset< StackDescriptor > Finish()
void add_strideY(uint32_t strideY)
flatbuffers::Offset< FullyConnectedDescriptor > Finish()
BatchNormalizationDescriptor Table
const armnnSerializer::LstmLayer * layer_as_LstmLayer() const
const armnnSerializer::MeanLayer * layer_as_MeanLayer() const
flatbuffers::Offset< ChannelShuffleLayer > CreateChannelShuffleLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ChannelShuffleDescriptor > descriptor=0)
void add_weights(flatbuffers::Offset< armnnSerializer::ConstTensor > weights)
bool alignCorners() const
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
flatbuffers::Offset< ShapeLayer > Finish()
InstanceNormalizationLayerBuilder Builder
flatbuffers::uoffset_t start_
flatbuffers::Offset< UintVector > CreateUintVector(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> data=0)
flatbuffers::uoffset_t start_
flatbuffers::Offset< StackLayer > CreateStackLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::StackDescriptor > descriptor=0)
TransposeLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
TransposeConvolution2dDescriptor Table
void add_descriptor(flatbuffers::Offset< armnnSerializer::DetectionPostProcessDescriptor > descriptor)
ReshapeDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
ArgMinMaxDescriptorBuilder Builder
ResizeLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::FillLayer * layer_as_FillLayer() const
flatbuffers::Offset< ReshapeLayer > Finish()
UintVectorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
LongDataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
UnidirectionalSequenceLstmDescriptorBuilder Builder
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::FlatBufferBuilder & fbb_
void add_descriptor(flatbuffers::Offset< armnnSerializer::OriginsDescriptor > descriptor)
flatbuffers::Offset< ViewsDescriptor > Finish()
ArgMinMaxLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
UnidirectionalSequenceLstmLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
SpaceToBatchNdLayer Table
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
TransposeDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
InstanceNormalizationDescriptor Table
uint32_t targetWidth() const
void add_poolWidth(uint32_t poolWidth)
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
StandInDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_alignCorners(bool alignCorners)
const armnnSerializer::PreluLayer * layer_as_PreluLayer() const
ByteDataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_peepholeEnabled(bool peepholeEnabled)
void add_biasEnabled(bool biasEnabled)
flatbuffers::Offset< StridedSliceLayer > Finish()
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_layerNormEnabled(bool layerNormEnabled)
const armnnSerializer::MeanDescriptor * descriptor() const
flatbuffers::Offset< Convolution2dLayer > CreateConvolution2dLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::Convolution2dDescriptor > descriptor=0, flatbuffers::Offset< armnnSerializer::ConstTensor > weights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > biases=0)
void add_beta(float beta)
const armnnSerializer::SpaceToDepthLayer * layer_as_SpaceToDepthLayer() const
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
flatbuffers::Offset< DepthwiseConvolution2dLayer > Finish()
UnidirectionalSequenceLstmDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
SpaceToBatchNdLayerBuilder Builder
flatbuffers::Offset< UnidirectionalSequenceLstmLayer > CreateUnidirectionalSequenceLstmLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::UnidirectionalSequenceLstmDescriptor > descriptor=0, flatbuffers::Offset< armnnSerializer::LstmInputParams > inputParams=0)
ActivationLayerBuilder Builder
void add_descriptor(flatbuffers::Offset< armnnSerializer::ArgMinMaxDescriptor > descriptor)
const armnnSerializer::SoftmaxLayer * layer_as_SoftmaxLayer() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const armnnSerializer::OutputLayer * layer_as_OutputLayer() const
const armnnSerializer::LstmInputParams * inputParams() const
flatbuffers::Offset< LogicalBinaryLayer > Finish()
flatbuffers::Offset< FloorLayer > Finish()
flatbuffers::Offset< Pooling2dLayer > CreatePooling2dLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::Pooling2dDescriptor > descriptor=0)
const armnnSerializer::ConstTensor * forgetLayerNormWeights() const
void add_scaleH(float scaleH)
UintVectorBuilder Builder
FullyConnectedLayerBuilder Builder
void add_numViews(uint32_t numViews)
void add_strideZ(uint32_t strideZ)
const armnnSerializer::QuantizeLayer * layer_as_QuantizeLayer() const
flatbuffers::Offset< FeatureCompatibilityVersions > Finish()
flatbuffers::Offset< MergerLayer > Finish()
flatbuffers::Offset< SpaceToBatchNdLayer > CreateSpaceToBatchNdLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::SpaceToBatchNdDescriptor > descriptor=0)
void add_descriptor(flatbuffers::Offset< armnnSerializer::Convolution2dDescriptor > descriptor)
flatbuffers::Offset< UnidirectionalSequenceLstmDescriptor > CreateUnidirectionalSequenceLstmDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t activationFunc=0, float clippingThresCell=0.0f, float clippingThresProj=0.0f, bool cifgEnabled=true, bool peepholeEnabled=false, bool projectionEnabled=false, bool layerNormEnabled=false, bool timeMajor=false)
ConstTensorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const flatbuffers::Vector< uint32_t > * crops() const
flatbuffers::uoffset_t start_
const armnnSerializer::DetectionPostProcessLayer * layer_as_DetectionPostProcessLayer() const
const armnnSerializer::FullyConnectedDescriptor * descriptor() const
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
void add_detectionsPerClass(uint32_t detectionsPerClass)
FullyConnectedLayer Table
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::ConstTensor * cellBias() const
Convolution2dLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_operation(armnnSerializer::ComparisonOperation operation)
ChannelShuffleDescriptorBuilder Builder
ChannelShuffleDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
bool VerifyConstTensorDataVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector< flatbuffers::Offset< void >> *values, const flatbuffers::Vector< uint8_t > *types)
int32_t hiddenStateZeroPoint() const
void add_value(float value)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
armnnSerializer::ArgMinMaxFunction argMinMaxFunction() const
InstanceNormalizationDescriptorBuilder Builder
const armnnSerializer::StackDescriptor * descriptor() const
flatbuffers::Offset< BatchToSpaceNdDescriptor > CreateBatchToSpaceNdDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint32_t > *blockShape=nullptr, const std::vector< uint32_t > *crops=nullptr, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
const armnnSerializer::ConstTensor * anchors() const
flatbuffers::uoffset_t start_
void add_descriptor(flatbuffers::Offset< armnnSerializer::LstmDescriptor > descriptor)
flatbuffers::Offset< ComparisonDescriptor > CreateComparisonDescriptor(flatbuffers::FlatBufferBuilder &_fbb, armnnSerializer::ComparisonOperation operation=armnnSerializer::ComparisonOperation_Equal)
flatbuffers::Offset< BatchToSpaceNdDescriptor > Finish()
flatbuffers::uoffset_t start_
const armnnSerializer::SpaceToDepthDescriptor * descriptor() const
flatbuffers::Offset< BindableLayerBase > Finish()
ComparisonDescriptor Table
InstanceNormalizationLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< MaximumLayer > CreateMaximumLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
flatbuffers::FlatBufferBuilder & fbb_
const char * EnumNameComparisonOperation(ComparisonOperation e)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const armnnSerializer::ConstTensor * recurrentToOutputWeights() const
void add_nmsIouThreshold(float nmsIouThreshold)
flatbuffers::uoffset_t start_
void add_alignCorners(bool alignCorners)
uint32_t numDimensions() const
flatbuffers::Offset< LstmLayer > Finish()
const char *const * EnumNamesArgMinMaxFunction()
void add_blockSize(uint32_t blockSize)
const armnnSerializer::StandInDescriptor * descriptor() const
VT_TRANSPOSEWEIGHTSMATRIX
AbsLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
SplitterLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_base(flatbuffers::Offset< armnnSerializer::BindableLayerBase > base)
const flatbuffers::Vector< float > * quantizationScales() const
flatbuffers::Offset< ByteData > CreateByteDataDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< int8_t > *data=nullptr)
const armnnSerializer::EqualLayer * layer_as_EqualLayer() const
DepthwiseConvolution2dDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< InstanceNormalizationDescriptor > CreateInstanceNormalizationDescriptor(flatbuffers::FlatBufferBuilder &_fbb, float gamma=0.0f, float beta=0.0f, float eps=0.0f, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
void add_dimensions(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> dimensions)
ActivationDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const char *const * EnumNamesPoolingAlgorithm()
AnyLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::OriginsDescriptor * descriptor() const
const armnnSerializer::ShortData * data_as_ShortData() const
BindableLayerBaseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::AbsLayer * layer_as_AbsLayer() const
void add_targetWidth(uint32_t targetWidth)
flatbuffers::uoffset_t start_
flatbuffers::Offset< ArgMinMaxLayer > Finish()
flatbuffers::Offset< MeanDescriptor > Finish()
const armnnSerializer::TransposeConvolution2dDescriptor * descriptor() const
float inputIntermediateScale() const
const armnnSerializer::ConstTensor * inputToCellWeights() const
L2NormalizationDescriptor Table
const flatbuffers::Vector< int32_t > * data() const
ReduceLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::MergeLayer * layer_as_MergeLayer() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
Convolution3dLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
VT_INPUTINTERMEDIATESCALE
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
const armnnSerializer::ViewsDescriptor * descriptor() const
void add_layer_type(armnnSerializer::Layer layer_type)
StackLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::uoffset_t start_
LogSoftmaxLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
void add_targetHeight(uint32_t targetHeight)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< IntData > CreateIntData(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< int32_t >> data=0)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const armnnSerializer::SliceDescriptor * descriptor() const
ElementwiseUnaryLayer Table
void add_targetShape(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> targetShape)
flatbuffers::Offset< ArgMinMaxDescriptor > Finish()
void add_padFront(uint32_t padFront)
void add_hiddenStateScale(float hiddenStateScale)
void add_layer(flatbuffers::Offset< void > layer)
StandInLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< ConcatLayer > Finish()
flatbuffers::uoffset_t start_
flatbuffers::Offset< ResizeLayer > CreateResizeLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ResizeDescriptor > descriptor=0)
armnnSerializer::PoolingAlgorithm poolType() const
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
int32_t newAxisMask() const
void add_paddingMethod(armnnSerializer::PaddingMethod paddingMethod)
flatbuffers::uoffset_t start_
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::Offset< FullyConnectedLayer > CreateFullyConnectedLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::FullyConnectedDescriptor > descriptor=0, flatbuffers::Offset< armnnSerializer::ConstTensor > weights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > biases=0)
flatbuffers::Offset< Convolution2dLayer > Finish()
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
const NormalizationAlgorithmChannel(& EnumValuesNormalizationAlgorithmChannel())[2]
const char * EnumNameLogicalBinaryOperation(LogicalBinaryOperation e)
GatherLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
ComparisonLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
flatbuffers::Offset< DequantizeLayer > CreateDequantizeLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
BatchToSpaceNdDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
StackLayerBuilder Builder
flatbuffers::Offset< ChannelShuffleDescriptor > CreateChannelShuffleDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t axis=0, uint32_t numGroups=0)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< ResizeBilinearLayer > CreateResizeBilinearLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ResizeBilinearDescriptor > descriptor=0)
flatbuffers::Offset< InstanceNormalizationDescriptor > Finish()
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< PadLayer > Finish()
void add_layerType(armnnSerializer::LayerType layerType)
flatbuffers::uoffset_t start_
float forgetIntermediateScale() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_tensorInfo(flatbuffers::Offset< armnnSerializer::TensorInfo > tensorInfo)
flatbuffers::uoffset_t start_
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_weights(flatbuffers::Offset< armnnSerializer::ConstTensor > weights)
uint32_t dilationZ() const
void FinishSizePrefixedSerializedGraphBuffer(flatbuffers::FlatBufferBuilder &fbb, flatbuffers::Offset< armnnSerializer::SerializedGraph > root)
DepthToSpaceDescriptorBuilder Builder
QuantizeLayerBuilder Builder
flatbuffers::Offset< ViewsDescriptor > CreateViewsDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::OriginsDescriptor > origins=0, const std::vector< flatbuffers::Offset< armnnSerializer::UintVector >> *viewSizes=nullptr)
void add_dilationX(uint32_t dilationX)
flatbuffers::FlatBufferBuilder & fbb_
Pooling2dLayerBuilder Builder
flatbuffers::Offset< PadDescriptor > Finish()
flatbuffers::Offset< OutputSlot > Finish()
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
BatchToSpaceNdDescriptorBuilder Builder
flatbuffers::Offset< OriginsDescriptor > CreateOriginsDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, uint32_t concatAxis=0, uint32_t numViews=0, uint32_t numDimensions=0, const std::vector< flatbuffers::Offset< armnnSerializer::UintVector >> *viewOrigins=nullptr)
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
const char * EnumNameDataType(DataType e)
DetectionPostProcessDescriptor Table
const char * EnumNamePaddingMethod(PaddingMethod e)
flatbuffers::FlatBufferBuilder & fbb_
void add_featureVersions(flatbuffers::Offset< armnnSerializer::FeatureCompatibilityVersions > featureVersions)
void add_padTop(uint32_t padTop)
flatbuffers::Offset< DetectionPostProcessLayer > CreateDetectionPostProcessLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::DetectionPostProcessDescriptor > descriptor=0, flatbuffers::Offset< armnnSerializer::ConstTensor > anchors=0)
const flatbuffers::Vector< int64_t > * data() const
void add_data(flatbuffers::Offset< flatbuffers::Vector< int16_t >> data)
MeanDescriptorBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
PadDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< StridedSliceDescriptor > CreateStridedSliceDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< int32_t > *begin=nullptr, const std::vector< int32_t > *end=nullptr, const std::vector< int32_t > *stride=nullptr, int32_t beginMask=0, int32_t endMask=0, int32_t shrinkAxisMask=0, int32_t ellipsisMask=0, int32_t newAxisMask=0, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
flatbuffers::Offset< Pooling2dDescriptor > Finish()
flatbuffers::uoffset_t start_
void add_clippingThresProj(float clippingThresProj)
ElementwiseUnaryDescriptor Table
SoftmaxDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
LogSoftmaxDescriptor Table
void add_descriptor(flatbuffers::Offset< armnnSerializer::MeanDescriptor > descriptor)
void add_reduceOperation(armnnSerializer::ReduceOperation reduceOperation)
flatbuffers::Offset< SpaceToBatchNdDescriptor > Finish()
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
SpaceToDepthDescriptor Table
flatbuffers::Offset< ComparisonDescriptor > Finish()
flatbuffers::Offset< QuantizedLstmLayer > Finish()
void add_data(flatbuffers::Offset< void > data)
const char * EnumNameOutputShapeRounding(OutputShapeRounding e)
void add_padLeft(uint32_t padLeft)
const armnnSerializer::ConstTensor * beta() const
RsqrtLayerBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
ResizeDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
const char * EnumNameNormalizationAlgorithmChannel(NormalizationAlgorithmChannel e)
SpaceToBatchNdDescriptorBuilder Builder
flatbuffers::Offset< BatchToSpaceNdLayer > CreateBatchToSpaceNdLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::BatchToSpaceNdDescriptor > descriptor=0)
uint32_t numGroups() const
void add_operation(armnnSerializer::UnaryOperation operation)
bool VerifySerializedGraphBuffer(flatbuffers::Verifier &verifier)
LogicalBinaryLayerBuilder Builder
L2NormalizationLayerBuilder Builder
flatbuffers::Offset< SliceDescriptor > Finish()
float nmsScoreThreshold() const
void add_halfPixelCenters(bool halfPixelCenters)
void add_padBottom(uint32_t padBottom)
const flatbuffers::Vector< uint32_t > * begin() const
bool SerializedGraphBufferHasIdentifier(const void *buf)
flatbuffers::Offset< UnidirectionalSequenceLstmDescriptor > Finish()
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::ResizeBilinearDescriptor * descriptor() const
const armnnSerializer::LongData * data_as_LongData() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const armnnSerializer::SubtractionLayer * layer_as_SubtractionLayer() const
flatbuffers::uoffset_t start_
SliceDescriptorBuilder Builder
void add_axis(int32_t axis)
flatbuffers::uoffset_t start_
const armnnSerializer::StackLayer * layer_as_StackLayer() const
flatbuffers::Offset< LogSoftmaxLayer > CreateLogSoftmaxLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::LogSoftmaxDescriptor > descriptor=0)
flatbuffers::FlatBufferBuilder & fbb_
void add_beta(flatbuffers::Offset< armnnSerializer::ConstTensor > beta)
const armnnSerializer::LogSoftmaxDescriptor * descriptor() const
flatbuffers::uoffset_t start_
UnidirectionalSequenceLstmDescriptor Table
UnidirectionalSequenceLstmLayerBuilder Builder
armnnSerializer::ConstTensorData data_type() const
void add_descriptor(flatbuffers::Offset< armnnSerializer::PermuteDescriptor > descriptor)
flatbuffers::Offset< StridedSliceDescriptor > CreateStridedSliceDescriptor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< int32_t >> begin=0, flatbuffers::Offset< flatbuffers::Vector< int32_t >> end=0, flatbuffers::Offset< flatbuffers::Vector< int32_t >> stride=0, int32_t beginMask=0, int32_t endMask=0, int32_t shrinkAxisMask=0, int32_t ellipsisMask=0, int32_t newAxisMask=0, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
flatbuffers::Offset< OriginsDescriptor > CreateOriginsDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t concatAxis=0, uint32_t numViews=0, uint32_t numDimensions=0, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::UintVector >>> viewOrigins=0)
flatbuffers::Offset< QLstmLayer > CreateQLstmLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::QLstmDescriptor > descriptor=0, flatbuffers::Offset< armnnSerializer::QLstmInputParams > inputParams=0)
void add_activationFunc(uint32_t activationFunc)
NormalizationAlgorithmMethod
flatbuffers::Offset< RankLayer > Finish()
flatbuffers::uoffset_t start_
void add_axis(int32_t axis)
uint32_t quantizationDim() const
flatbuffers::Offset< ReduceDescriptor > CreateReduceDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, bool keepDims=false, const std::vector< uint32_t > *axis=nullptr, armnnSerializer::ReduceOperation reduceOperation=armnnSerializer::ReduceOperation_Sum)
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::ConstTensor * outputGateBias() const
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< LstmDescriptor > CreateLstmDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t activationFunc=0, float clippingThresCell=0.0f, float clippingThresProj=0.0f, bool cifgEnabled=true, bool peepholeEnabled=false, bool projectionEnabled=false, bool layerNormEnabled=false)
flatbuffers::FlatBufferBuilder & fbb_
const flatbuffers::Vector< uint32_t > * data() const
flatbuffers::Offset< L2NormalizationDescriptor > Finish()
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const char * SerializedGraphExtension()
const flatbuffers::Vector< uint32_t > * padList() const
void add_strideY(uint32_t strideY)
OutputSlotBuilder Builder
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
BatchToSpaceNdLayerBuilder Builder
flatbuffers::Offset< ElementwiseUnaryLayer > CreateElementwiseUnaryLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ElementwiseUnaryDescriptor > descriptor=0)
FLATBUFFERS_STRUCT_END(Connection, 8)
flatbuffers::Offset< PermuteLayer > CreatePermuteLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::PermuteDescriptor > descriptor=0)
const ReduceOperation(& EnumValuesReduceOperation())[5]
void add_outputShapeRounding(armnnSerializer::OutputShapeRounding outputShapeRounding)
const armnnSerializer::L2NormalizationLayer * layer_as_L2NormalizationLayer() const
flatbuffers::Offset< GatherDescriptor > Finish()
FloorLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
void add_descriptor(flatbuffers::Offset< armnnSerializer::BatchNormalizationDescriptor > descriptor)
float hiddenStateScale() const
void add_weights(flatbuffers::Offset< armnnSerializer::ConstTensor > weights)
const armnnSerializer::ArgMinMaxDescriptor * descriptor() const
const UnaryOperation(& EnumValuesUnaryOperation())[8]
ShortDataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const char *const * EnumNamesUnaryOperation()
void add_inputParams(flatbuffers::Offset< armnnSerializer::LstmInputParams > inputParams)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< SpaceToBatchNdDescriptor > CreateSpaceToBatchNdDescriptor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> blockShape=0, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> padList=0, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
const char * EnumNameLayerType(LayerType e)
InstanceNormalizationDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const void * data() const
const armnnSerializer::SerializedGraph * GetSizePrefixedSerializedGraph(const void *buf)
flatbuffers::Offset< PermuteDescriptor > CreatePermuteDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint32_t > *dimMappings=nullptr)
void add_origins(flatbuffers::Offset< armnnSerializer::OriginsDescriptor > origins)
const armnnSerializer::TransposeLayer * layer_as_TransposeLayer() const
const armnnSerializer::InstanceNormalizationDescriptor * descriptor() const
flatbuffers::FlatBufferBuilder & fbb_
PermuteLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
void add_biasEnabled(bool biasEnabled)
flatbuffers::Offset< MergeLayer > Finish()
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< SerializedGraph > CreateSerializedGraph(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::AnyLayer >>> layers=0, flatbuffers::Offset< flatbuffers::Vector< int32_t >> inputIds=0, flatbuffers::Offset< flatbuffers::Vector< int32_t >> outputIds=0, flatbuffers::Offset< armnnSerializer::FeatureCompatibilityVersions > featureVersions=0)
flatbuffers::FlatBufferBuilder & fbb_
void add_dimensionSpecificity(flatbuffers::Offset< flatbuffers::Vector< uint8_t >> dimensionSpecificity)
flatbuffers::Offset< TransposeDescriptor > Finish()
uint32_t detectionsPerClass() const
L2NormalizationLayer Table
void add_dilationX(uint32_t dilationX)
void add_descriptor(flatbuffers::Offset< armnnSerializer::SpaceToDepthDescriptor > descriptor)
const char *const * EnumNamesPaddingMethod()
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
DetectionPostProcessLayer Table
flatbuffers::uoffset_t start_
LogSoftmaxDescriptorBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< ResizeBilinearLayer > Finish()
void add_numInputs(uint32_t numInputs)
void add_descriptor(flatbuffers::Offset< armnnSerializer::OriginsDescriptor > descriptor)
flatbuffers::uoffset_t start_
OutputLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
LogicalBinaryDescriptorBuilder Builder
const flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::AnyLayer > > * layers() const
const char * EnumNameDataLayout(DataLayout e)
VT_FORGETLAYERNORMWEIGHTS
SpaceToDepthDescriptor DepthToSpaceDescriptor
A DepthToSpaceDescriptor for the DepthToSpaceLayer.
void add_beta(float beta)
flatbuffers::Offset< LogicalBinaryDescriptor > CreateLogicalBinaryDescriptor(flatbuffers::FlatBufferBuilder &_fbb, armnnSerializer::LogicalBinaryOperation operation=armnnSerializer::LogicalBinaryOperation_LogicalAnd)
VT_OUTPUTINTERMEDIATESCALE
flatbuffers::Offset< DivisionLayer > CreateDivisionLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
armnnSerializer::PaddingMethod paddingMethod() const
MinimumLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
uint32_t numInputs() const
void add_padRight(uint32_t padRight)
SpaceToDepthLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_layers(flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::AnyLayer >>> layers)
const flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::InputSlot > > * inputSlots() const
flatbuffers::Offset< LogicalBinaryLayer > CreateLogicalBinaryLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::LogicalBinaryDescriptor > descriptor=0)
const armnnSerializer::Pooling3dDescriptor * Pooling3dDescriptor
const armnnSerializer::DetectionPostProcessDescriptor * descriptor() const
SpaceToBatchNdDescriptor Table
Pooling2dDescriptor Table
ReshapeLayerBuilder Builder
const armnnSerializer::ConstTensor * input() const
const armnnSerializer::MinimumLayer * layer_as_MinimumLayer() const
flatbuffers::uoffset_t start_
const armnnSerializer::DepthToSpaceLayer * layer_as_DepthToSpaceLayer() const
const armnnSerializer::GatherDescriptor * descriptor() const
void add_padRight(uint32_t padRight)
const armnnSerializer::Connection * connection() const
flatbuffers::FlatBufferBuilder & fbb_
uint32_t dilationY() const
void add_descriptor(flatbuffers::Offset< armnnSerializer::StandInDescriptor > descriptor)
int32_t quantizationOffset() const
flatbuffers::FlatBufferBuilder & fbb_
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
PadLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
void add_data(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> data)