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 Pooling2dDescriptor;
177 struct Pooling2dDescriptorBuilder;
179 struct QuantizeLayer;
180 struct QuantizeLayerBuilder;
183 struct SoftmaxLayerBuilder;
185 struct SoftmaxDescriptor;
186 struct SoftmaxDescriptorBuilder;
188 struct DepthwiseConvolution2dLayer;
189 struct DepthwiseConvolution2dLayerBuilder;
191 struct DepthwiseConvolution2dDescriptor;
192 struct DepthwiseConvolution2dDescriptorBuilder;
195 struct OutputLayerBuilder;
198 struct ReshapeLayerBuilder;
200 struct ReshapeDescriptor;
201 struct ReshapeDescriptorBuilder;
204 struct PermuteLayerBuilder;
206 struct PermuteDescriptor;
207 struct PermuteDescriptorBuilder;
210 struct ShapeLayerBuilder;
212 struct SpaceToBatchNdLayer;
213 struct SpaceToBatchNdLayerBuilder;
215 struct SpaceToBatchNdDescriptor;
216 struct SpaceToBatchNdDescriptorBuilder;
218 struct SpaceToDepthLayer;
219 struct SpaceToDepthLayerBuilder;
221 struct SpaceToDepthDescriptor;
222 struct SpaceToDepthDescriptorBuilder;
224 struct SubtractionLayer;
225 struct SubtractionLayerBuilder;
227 struct BatchToSpaceNdLayer;
228 struct BatchToSpaceNdLayerBuilder;
230 struct BatchToSpaceNdDescriptor;
231 struct BatchToSpaceNdDescriptorBuilder;
233 struct NormalizationLayer;
234 struct NormalizationLayerBuilder;
236 struct NormalizationDescriptor;
237 struct NormalizationDescriptorBuilder;
240 struct MeanLayerBuilder;
242 struct MeanDescriptor;
243 struct MeanDescriptorBuilder;
246 struct PadLayerBuilder;
248 struct PadDescriptor;
249 struct PadDescriptorBuilder;
252 struct RsqrtLayerBuilder;
254 struct BatchNormalizationLayer;
255 struct BatchNormalizationLayerBuilder;
257 struct BatchNormalizationDescriptor;
258 struct BatchNormalizationDescriptorBuilder;
260 struct ResizeBilinearLayer;
261 struct ResizeBilinearLayerBuilder;
263 struct ResizeBilinearDescriptor;
264 struct ResizeBilinearDescriptorBuilder;
267 struct SliceLayerBuilder;
269 struct SliceDescriptor;
270 struct SliceDescriptorBuilder;
272 struct StridedSliceLayer;
273 struct StridedSliceLayerBuilder;
275 struct StridedSliceDescriptor;
276 struct StridedSliceDescriptorBuilder;
279 struct ConcatLayerBuilder;
282 struct MergerLayerBuilder;
285 struct UintVectorBuilder;
287 struct OriginsDescriptor;
288 struct OriginsDescriptorBuilder;
290 struct ViewsDescriptor;
291 struct ViewsDescriptorBuilder;
293 struct SplitterLayer;
294 struct SplitterLayerBuilder;
296 struct DetectionPostProcessLayer;
297 struct DetectionPostProcessLayerBuilder;
299 struct DetectionPostProcessDescriptor;
300 struct DetectionPostProcessDescriptorBuilder;
302 struct LstmInputParams;
303 struct LstmInputParamsBuilder;
305 struct LstmDescriptor;
306 struct LstmDescriptorBuilder;
309 struct LstmLayerBuilder;
311 struct QLstmInputParams;
312 struct QLstmInputParamsBuilder;
314 struct QLstmDescriptor;
315 struct QLstmDescriptorBuilder;
318 struct QLstmLayerBuilder;
320 struct QuantizedLstmInputParams;
321 struct QuantizedLstmInputParamsBuilder;
323 struct QuantizedLstmLayer;
324 struct QuantizedLstmLayerBuilder;
326 struct DequantizeLayer;
327 struct DequantizeLayerBuilder;
330 struct MergeLayerBuilder;
333 struct SwitchLayerBuilder;
336 struct PreluLayerBuilder;
338 struct TransposeConvolution2dLayer;
339 struct TransposeConvolution2dLayerBuilder;
341 struct TransposeConvolution2dDescriptor;
342 struct TransposeConvolution2dDescriptorBuilder;
344 struct TransposeLayer;
345 struct TransposeLayerBuilder;
347 struct TransposeDescriptor;
348 struct TransposeDescriptorBuilder;
351 struct ResizeLayerBuilder;
353 struct ResizeDescriptor;
354 struct ResizeDescriptorBuilder;
357 struct StackLayerBuilder;
359 struct StackDescriptor;
360 struct StackDescriptorBuilder;
362 struct StandInDescriptor;
363 struct StandInDescriptorBuilder;
366 struct StandInLayerBuilder;
369 struct RankLayerBuilder;
372 struct ReduceLayerBuilder;
374 struct ReduceDescriptor;
375 struct ReduceDescriptorBuilder;
378 struct UnidirectionalSequenceLstmDescriptorBuilder;
380 struct UnidirectionalSequenceLstmLayer;
381 struct UnidirectionalSequenceLstmLayerBuilder;
384 struct AnyLayerBuilder;
386 struct FeatureCompatibilityVersions;
387 struct FeatureCompatibilityVersionsBuilder;
389 struct SerializedGraph;
390 struct SerializedGraphBuilder;
428 static const char *
const names[13] = {
448 const size_t index =
static_cast<size_t>(e);
468 static const char *
const names[3] = {
478 const size_t index =
static_cast<size_t>(e);
516 static const char *
const names[12] = {
535 const size_t index =
static_cast<size_t>(e);
559 static const char *
const names[5] = {
571 const size_t index =
static_cast<size_t>(e);
597 static const char *
const names[6] = {
610 const size_t index =
static_cast<size_t>(e);
630 static const char *
const names[3] = {
640 const size_t index =
static_cast<size_t>(e);
666 static const char *
const names[6] = {
679 const size_t index =
static_cast<size_t>(e);
704 bool VerifyConstTensorDataVector(flatbuffers::Verifier &verifier,
const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
const flatbuffers::Vector<uint8_t> *types);
850 static const char *
const names[67] = {
859 "DepthwiseConvolution2d",
874 "BatchNormalization",
884 "DetectionPostProcess",
893 "TransposeConvolution2d",
901 "InstanceNormalization",
914 "UnidirectionalSequenceLstm",
924 const size_t index =
static_cast<size_t>(e);
952 static const char *
const names[7] = {
966 const size_t index =
static_cast<size_t>(e);
998 static const char *
const names[9] = {
1014 const size_t index =
static_cast<size_t>(e);
1034 static const char *
const names[3] = {
1044 const size_t index =
static_cast<size_t>(e);
1066 static const char *
const names[4] = {
1077 const size_t index =
static_cast<size_t>(e);
1097 static const char *
const names[3] = {
1107 const size_t index =
static_cast<size_t>(e);
1127 static const char *
const names[3] = {
1137 const size_t index =
static_cast<size_t>(e);
1157 static const char *
const names[3] = {
1167 const size_t index =
static_cast<size_t>(e);
1187 static const char *
const names[3] = {
1197 const size_t index =
static_cast<size_t>(e);
1219 static const char *
const names[4] = {
1230 const size_t index =
static_cast<size_t>(e);
1307 static const Layer values[] = {
1380 static const char *
const names[68] = {
1384 "BatchToSpaceNdLayer",
1385 "BatchNormalizationLayer",
1387 "Convolution2dLayer",
1388 "DepthwiseConvolution2dLayer",
1389 "FullyConnectedLayer",
1391 "MultiplicationLayer",
1397 "SpaceToBatchNdLayer",
1402 "NormalizationLayer",
1407 "ResizeBilinearLayer",
1409 "StridedSliceLayer",
1413 "L2NormalizationLayer",
1415 "DetectionPostProcessLayer",
1417 "QuantizedLstmLayer",
1423 "SpaceToDepthLayer",
1425 "TransposeConvolution2dLayer",
1431 "DepthToSpaceLayer",
1432 "InstanceNormalizationLayer",
1436 "ElementwiseUnaryLayer",
1441 "LogicalBinaryLayer",
1445 "UnidirectionalSequenceLstmLayer",
1446 "ChannelShuffleLayer",
1447 "Convolution3dLayer",
1455 const size_t index =
static_cast<size_t>(e);
1727 bool VerifyLayer(flatbuffers::Verifier &verifier,
const void *obj,
Layer type);
1728 bool VerifyLayerVector(flatbuffers::Verifier &verifier,
const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
const flatbuffers::Vector<uint8_t> *types);
1732 uint32_t sourceLayerIndex_;
1733 uint32_t outputSlotIndex_;
1737 memset(static_cast<void *>(
this), 0,
sizeof(Connection));
1739 Connection(uint32_t _sourceLayerIndex, uint32_t _outputSlotIndex)
1740 : sourceLayerIndex_(flatbuffers::EndianScalar(_sourceLayerIndex)),
1741 outputSlotIndex_(flatbuffers::EndianScalar(_outputSlotIndex)) {
1743 uint32_t sourceLayerIndex()
const {
1744 return flatbuffers::EndianScalar(sourceLayerIndex_);
1746 uint32_t outputSlotIndex()
const {
1747 return flatbuffers::EndianScalar(outputSlotIndex_);
1754 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1766 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_DIMENSIONS);
1790 return GetField<uint8_t>(VT_ISCONSTANT, 0) != 0;
1792 bool Verify(flatbuffers::Verifier &verifier)
const {
1793 return VerifyTableStart(verifier) &&
1795 verifier.VerifyVector(dimensions()) &&
1800 verifier.VerifyVector(quantizationScales()) &&
1804 verifier.VerifyVector(dimensionSpecificity()) &&
1805 VerifyField<uint8_t>(verifier, VT_ISCONSTANT) &&
1806 verifier.EndTable();
1812 flatbuffers::FlatBufferBuilder &
fbb_;
1839 fbb_.AddElement<uint8_t>(TensorInfo::VT_ISCONSTANT,
static_cast<uint8_t
>(isConstant), 0);
1843 start_ = fbb_.StartTable();
1847 const auto end = fbb_.EndTable(start_);
1848 auto o = flatbuffers::Offset<TensorInfo>(end);
1854 flatbuffers::FlatBufferBuilder &_fbb,
1857 float quantizationScale = 1.0f,
1858 int32_t quantizationOffset = 0,
1860 uint32_t quantizationDim = 0,
1861 uint32_t dimensionality = 1,
1863 bool isConstant =
false) {
1874 return builder_.
Finish();
1878 flatbuffers::FlatBufferBuilder &_fbb,
1879 const std::vector<uint32_t> *dimensions =
nullptr,
1881 float quantizationScale = 1.0f,
1882 int32_t quantizationOffset = 0,
1883 const std::vector<float> *quantizationScales =
nullptr,
1884 uint32_t quantizationDim = 0,
1885 uint32_t dimensionality = 1,
1886 const std::vector<uint8_t> *dimensionSpecificity =
nullptr,
1887 bool isConstant =
false) {
1888 auto dimensions__ = dimensions ? _fbb.CreateVector<uint32_t>(*dimensions) : 0;
1889 auto quantizationScales__ = quantizationScales ? _fbb.CreateVector<
float>(*quantizationScales) : 0;
1890 auto dimensionSpecificity__ = dimensionSpecificity ? _fbb.CreateVector<uint8_t>(*dimensionSpecificity) : 0;
1897 quantizationScales__,
1900 dimensionSpecificity__,
1904 struct ByteData FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
1906 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1909 const flatbuffers::Vector<int8_t> *
data()
const {
1910 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_DATA);
1912 bool Verify(flatbuffers::Verifier &verifier)
const {
1913 return VerifyTableStart(verifier) &&
1914 VerifyOffset(verifier, VT_DATA) &&
1915 verifier.VerifyVector(data()) &&
1916 verifier.EndTable();
1922 flatbuffers::FlatBufferBuilder &
fbb_;
1925 fbb_.AddOffset(ByteData::VT_DATA, data);
1929 start_ = fbb_.StartTable();
1933 const auto end = fbb_.EndTable(start_);
1934 auto o = flatbuffers::Offset<ByteData>(end);
1940 flatbuffers::FlatBufferBuilder &_fbb,
1944 return builder_.
Finish();
1948 flatbuffers::FlatBufferBuilder &_fbb,
1949 const std::vector<int8_t> *data =
nullptr) {
1950 auto data__ = data ? _fbb.CreateVector<int8_t>(*data) : 0;
1956 struct ShortData FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
1958 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1961 const flatbuffers::Vector<int16_t> *
data()
const {
1962 return GetPointer<const flatbuffers::Vector<int16_t> *>(VT_DATA);
1964 bool Verify(flatbuffers::Verifier &verifier)
const {
1965 return VerifyTableStart(verifier) &&
1966 VerifyOffset(verifier, VT_DATA) &&
1967 verifier.VerifyVector(data()) &&
1968 verifier.EndTable();
1974 flatbuffers::FlatBufferBuilder &
fbb_;
1977 fbb_.AddOffset(ShortData::VT_DATA, data);
1981 start_ = fbb_.StartTable();
1985 const auto end = fbb_.EndTable(start_);
1986 auto o = flatbuffers::Offset<ShortData>(end);
1992 flatbuffers::FlatBufferBuilder &_fbb,
1996 return builder_.
Finish();
2000 flatbuffers::FlatBufferBuilder &_fbb,
2001 const std::vector<int16_t> *data =
nullptr) {
2002 auto data__ = data ? _fbb.CreateVector<int16_t>(*data) : 0;
2008 struct IntData FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2010 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2013 const flatbuffers::Vector<int32_t> *
data()
const {
2014 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_DATA);
2016 bool Verify(flatbuffers::Verifier &verifier)
const {
2017 return VerifyTableStart(verifier) &&
2018 VerifyOffset(verifier, VT_DATA) &&
2019 verifier.VerifyVector(data()) &&
2020 verifier.EndTable();
2026 flatbuffers::FlatBufferBuilder &
fbb_;
2029 fbb_.AddOffset(IntData::VT_DATA, data);
2033 start_ = fbb_.StartTable();
2037 const auto end = fbb_.EndTable(start_);
2038 auto o = flatbuffers::Offset<IntData>(end);
2044 flatbuffers::FlatBufferBuilder &_fbb,
2048 return builder_.
Finish();
2052 flatbuffers::FlatBufferBuilder &_fbb,
2053 const std::vector<int32_t> *data =
nullptr) {
2054 auto data__ = data ? _fbb.CreateVector<int32_t>(*data) : 0;
2060 struct LongData FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2062 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2065 const flatbuffers::Vector<int64_t> *
data()
const {
2066 return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_DATA);
2068 bool Verify(flatbuffers::Verifier &verifier)
const {
2069 return VerifyTableStart(verifier) &&
2070 VerifyOffset(verifier, VT_DATA) &&
2071 verifier.VerifyVector(data()) &&
2072 verifier.EndTable();
2078 flatbuffers::FlatBufferBuilder &
fbb_;
2081 fbb_.AddOffset(LongData::VT_DATA, data);
2085 start_ = fbb_.StartTable();
2089 const auto end = fbb_.EndTable(start_);
2090 auto o = flatbuffers::Offset<LongData>(end);
2096 flatbuffers::FlatBufferBuilder &_fbb,
2100 return builder_.
Finish();
2104 flatbuffers::FlatBufferBuilder &_fbb,
2105 const std::vector<int64_t> *data =
nullptr) {
2106 auto data__ = data ? _fbb.CreateVector<int64_t>(*data) : 0;
2112 struct ConstTensor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2114 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2119 const armnnSerializer::TensorInfo *
info()
const {
2120 return GetPointer<const armnnSerializer::TensorInfo *>(
VT_INFO);
2126 return GetPointer<const void *>(VT_DATA);
2128 template<
typename T>
const T *data_as()
const;
2141 bool Verify(flatbuffers::Verifier &verifier)
const {
2142 return VerifyTableStart(verifier) &&
2143 VerifyOffset(verifier,
VT_INFO) &&
2144 verifier.VerifyTable(info()) &&
2146 VerifyOffset(verifier, VT_DATA) &&
2148 verifier.EndTable();
2152 template<>
inline const armnnSerializer::ByteData *ConstTensor::data_as<armnnSerializer::ByteData>()
const {
2153 return data_as_ByteData();
2156 template<>
inline const armnnSerializer::ShortData *ConstTensor::data_as<armnnSerializer::ShortData>()
const {
2157 return data_as_ShortData();
2160 template<>
inline const armnnSerializer::IntData *ConstTensor::data_as<armnnSerializer::IntData>()
const {
2161 return data_as_IntData();
2164 template<>
inline const armnnSerializer::LongData *ConstTensor::data_as<armnnSerializer::LongData>()
const {
2165 return data_as_LongData();
2170 flatbuffers::FlatBufferBuilder &
fbb_;
2172 void add_info(flatbuffers::Offset<armnnSerializer::TensorInfo> info) {
2179 fbb_.AddOffset(ConstTensor::VT_DATA, data);
2183 start_ = fbb_.StartTable();
2187 const auto end = fbb_.EndTable(start_);
2188 auto o = flatbuffers::Offset<ConstTensor>(end);
2194 flatbuffers::FlatBufferBuilder &_fbb,
2195 flatbuffers::Offset<armnnSerializer::TensorInfo> info = 0,
2197 flatbuffers::Offset<void> data = 0) {
2202 return builder_.
Finish();
2205 struct InputSlot FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2207 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2212 return GetField<uint32_t>(
VT_INDEX, 0);
2215 return GetStruct<const armnnSerializer::Connection *>(VT_CONNECTION);
2217 bool Verify(flatbuffers::Verifier &verifier)
const {
2218 return VerifyTableStart(verifier) &&
2219 VerifyField<uint32_t>(verifier,
VT_INDEX) &&
2220 VerifyField<armnnSerializer::Connection>(verifier, VT_CONNECTION) &&
2221 verifier.EndTable();
2227 flatbuffers::FlatBufferBuilder &
fbb_;
2233 fbb_.AddStruct(InputSlot::VT_CONNECTION, connection);
2237 start_ = fbb_.StartTable();
2241 const auto end = fbb_.EndTable(start_);
2242 auto o = flatbuffers::Offset<InputSlot>(end);
2248 flatbuffers::FlatBufferBuilder &_fbb,
2250 const armnnSerializer::Connection *connection = 0) {
2254 return builder_.
Finish();
2257 struct OutputSlot FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2259 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2264 return GetField<uint32_t>(
VT_INDEX, 0);
2267 return GetPointer<const armnnSerializer::TensorInfo *>(VT_TENSORINFO);
2269 bool Verify(flatbuffers::Verifier &verifier)
const {
2270 return VerifyTableStart(verifier) &&
2271 VerifyField<uint32_t>(verifier,
VT_INDEX) &&
2272 VerifyOffset(verifier, VT_TENSORINFO) &&
2273 verifier.VerifyTable(tensorInfo()) &&
2274 verifier.EndTable();
2280 flatbuffers::FlatBufferBuilder &
fbb_;
2286 fbb_.AddOffset(OutputSlot::VT_TENSORINFO, tensorInfo);
2290 start_ = fbb_.StartTable();
2294 const auto end = fbb_.EndTable(start_);
2295 auto o = flatbuffers::Offset<OutputSlot>(end);
2301 flatbuffers::FlatBufferBuilder &_fbb,
2303 flatbuffers::Offset<armnnSerializer::TensorInfo> tensorInfo = 0) {
2307 return builder_.
Finish();
2310 struct LayerBase FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2312 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2320 return GetField<uint32_t>(
VT_INDEX, 0);
2323 return GetPointer<const flatbuffers::String *>(
VT_LAYERNAME);
2328 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::InputSlot>> *
inputSlots()
const {
2329 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::InputSlot>> *>(
VT_INPUTSLOTS);
2331 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::OutputSlot>> *
outputSlots()
const {
2332 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::OutputSlot>> *>(VT_OUTPUTSLOTS);
2334 bool Verify(flatbuffers::Verifier &verifier)
const {
2335 return VerifyTableStart(verifier) &&
2336 VerifyField<uint32_t>(verifier,
VT_INDEX) &&
2338 verifier.VerifyString(layerName()) &&
2341 verifier.VerifyVector(inputSlots()) &&
2342 verifier.VerifyVectorOfTables(inputSlots()) &&
2343 VerifyOffset(verifier, VT_OUTPUTSLOTS) &&
2344 verifier.VerifyVector(outputSlots()) &&
2345 verifier.VerifyVectorOfTables(outputSlots()) &&
2346 verifier.EndTable();
2352 flatbuffers::FlatBufferBuilder &
fbb_;
2367 fbb_.AddOffset(LayerBase::VT_OUTPUTSLOTS, outputSlots);
2371 start_ = fbb_.StartTable();
2375 const auto end = fbb_.EndTable(start_);
2376 auto o = flatbuffers::Offset<LayerBase>(end);
2382 flatbuffers::FlatBufferBuilder &_fbb,
2384 flatbuffers::Offset<flatbuffers::String> layerName = 0,
2386 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::InputSlot>>> inputSlots = 0,
2387 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::OutputSlot>>> outputSlots = 0) {
2394 return builder_.
Finish();
2398 flatbuffers::FlatBufferBuilder &_fbb,
2400 const char *layerName =
nullptr,
2402 const std::vector<flatbuffers::Offset<armnnSerializer::InputSlot>> *inputSlots =
nullptr,
2403 const std::vector<flatbuffers::Offset<armnnSerializer::OutputSlot>> *outputSlots =
nullptr) {
2404 auto layerName__ = layerName ? _fbb.CreateString(layerName) : 0;
2405 auto inputSlots__ = inputSlots ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::InputSlot>>(*inputSlots) : 0;
2406 auto outputSlots__ = outputSlots ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::OutputSlot>>(*outputSlots) : 0;
2416 struct BindableLayerBase FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2418 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2420 VT_LAYERBINDINGID = 6
2422 const armnnSerializer::LayerBase *
base()
const {
2423 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2426 return GetField<int32_t>(VT_LAYERBINDINGID, 0);
2428 bool Verify(flatbuffers::Verifier &verifier)
const {
2429 return VerifyTableStart(verifier) &&
2430 VerifyOffset(verifier,
VT_BASE) &&
2431 verifier.VerifyTable(base()) &&
2432 VerifyField<int32_t>(verifier, VT_LAYERBINDINGID) &&
2433 verifier.EndTable();
2439 flatbuffers::FlatBufferBuilder &
fbb_;
2441 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2445 fbb_.AddElement<int32_t>(BindableLayerBase::VT_LAYERBINDINGID, layerBindingId, 0);
2449 start_ = fbb_.StartTable();
2452 flatbuffers::Offset<BindableLayerBase>
Finish() {
2453 const auto end = fbb_.EndTable(start_);
2454 auto o = flatbuffers::Offset<BindableLayerBase>(end);
2460 flatbuffers::FlatBufferBuilder &_fbb,
2461 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2462 int32_t layerBindingId = 0) {
2466 return builder_.
Finish();
2470 struct AbsLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2472 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2475 const armnnSerializer::LayerBase *
base()
const {
2476 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2478 bool Verify(flatbuffers::Verifier &verifier)
const {
2479 return VerifyTableStart(verifier) &&
2480 VerifyOffset(verifier,
VT_BASE) &&
2481 verifier.VerifyTable(base()) &&
2482 verifier.EndTable();
2488 flatbuffers::FlatBufferBuilder &
fbb_;
2490 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2495 start_ = fbb_.StartTable();
2499 const auto end = fbb_.EndTable(start_);
2500 auto o = flatbuffers::Offset<AbsLayer>(end);
2506 flatbuffers::FlatBufferBuilder &_fbb,
2507 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
2510 return builder_.
Finish();
2513 struct ActivationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2515 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2519 const armnnSerializer::LayerBase *
base()
const {
2520 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2522 const armnnSerializer::ActivationDescriptor *
descriptor()
const {
2523 return GetPointer<const armnnSerializer::ActivationDescriptor *>(
VT_DESCRIPTOR);
2525 bool Verify(flatbuffers::Verifier &verifier)
const {
2526 return VerifyTableStart(verifier) &&
2527 VerifyOffset(verifier,
VT_BASE) &&
2528 verifier.VerifyTable(base()) &&
2530 verifier.VerifyTable(descriptor()) &&
2531 verifier.EndTable();
2537 flatbuffers::FlatBufferBuilder &
fbb_;
2539 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2542 void add_descriptor(flatbuffers::Offset<armnnSerializer::ActivationDescriptor> descriptor) {
2547 start_ = fbb_.StartTable();
2550 flatbuffers::Offset<ActivationLayer>
Finish() {
2551 const auto end = fbb_.EndTable(start_);
2552 auto o = flatbuffers::Offset<ActivationLayer>(end);
2558 flatbuffers::FlatBufferBuilder &_fbb,
2559 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2560 flatbuffers::Offset<armnnSerializer::ActivationDescriptor> descriptor = 0) {
2564 return builder_.
Finish();
2567 struct ActivationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2569 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2578 return GetField<float>(
VT_A, 0.0f);
2581 return GetField<float>(VT_B, 0.0f);
2583 bool Verify(flatbuffers::Verifier &verifier)
const {
2584 return VerifyTableStart(verifier) &&
2586 VerifyField<float>(verifier,
VT_A) &&
2587 VerifyField<float>(verifier, VT_B) &&
2588 verifier.EndTable();
2594 flatbuffers::FlatBufferBuilder &
fbb_;
2603 fbb_.AddElement<
float>(ActivationDescriptor::VT_B, b, 0.0f);
2607 start_ = fbb_.StartTable();
2610 flatbuffers::Offset<ActivationDescriptor>
Finish() {
2611 const auto end = fbb_.EndTable(start_);
2612 auto o = flatbuffers::Offset<ActivationDescriptor>(end);
2618 flatbuffers::FlatBufferBuilder &_fbb,
2626 return builder_.
Finish();
2629 struct AdditionLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2631 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2634 const armnnSerializer::LayerBase *
base()
const {
2635 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2637 bool Verify(flatbuffers::Verifier &verifier)
const {
2638 return VerifyTableStart(verifier) &&
2639 VerifyOffset(verifier,
VT_BASE) &&
2640 verifier.VerifyTable(base()) &&
2641 verifier.EndTable();
2647 flatbuffers::FlatBufferBuilder &
fbb_;
2649 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2654 start_ = fbb_.StartTable();
2657 flatbuffers::Offset<AdditionLayer>
Finish() {
2658 const auto end = fbb_.EndTable(start_);
2659 auto o = flatbuffers::Offset<AdditionLayer>(end);
2665 flatbuffers::FlatBufferBuilder &_fbb,
2666 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
2669 return builder_.
Finish();
2672 struct ArgMinMaxLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2674 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2678 const armnnSerializer::LayerBase *
base()
const {
2679 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2682 return GetPointer<const armnnSerializer::ArgMinMaxDescriptor *>(
VT_DESCRIPTOR);
2684 bool Verify(flatbuffers::Verifier &verifier)
const {
2685 return VerifyTableStart(verifier) &&
2686 VerifyOffset(verifier,
VT_BASE) &&
2687 verifier.VerifyTable(base()) &&
2689 verifier.VerifyTable(descriptor()) &&
2690 verifier.EndTable();
2696 flatbuffers::FlatBufferBuilder &
fbb_;
2698 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2701 void add_descriptor(flatbuffers::Offset<armnnSerializer::ArgMinMaxDescriptor> descriptor) {
2706 start_ = fbb_.StartTable();
2709 flatbuffers::Offset<ArgMinMaxLayer>
Finish() {
2710 const auto end = fbb_.EndTable(start_);
2711 auto o = flatbuffers::Offset<ArgMinMaxLayer>(end);
2717 flatbuffers::FlatBufferBuilder &_fbb,
2718 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2719 flatbuffers::Offset<armnnSerializer::ArgMinMaxDescriptor> descriptor = 0) {
2723 return builder_.
Finish();
2726 struct ArgMinMaxDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2728 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2736 return GetField<int32_t>(
VT_AXIS, 0);
2738 bool Verify(flatbuffers::Verifier &verifier)
const {
2739 return VerifyTableStart(verifier) &&
2741 VerifyField<int32_t>(verifier,
VT_AXIS) &&
2742 verifier.EndTable();
2748 flatbuffers::FlatBufferBuilder &
fbb_;
2758 start_ = fbb_.StartTable();
2761 flatbuffers::Offset<ArgMinMaxDescriptor>
Finish() {
2762 const auto end = fbb_.EndTable(start_);
2763 auto o = flatbuffers::Offset<ArgMinMaxDescriptor>(end);
2769 flatbuffers::FlatBufferBuilder &_fbb,
2775 return builder_.
Finish();
2778 struct CastLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2780 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2783 const armnnSerializer::LayerBase *
base()
const {
2784 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2786 bool Verify(flatbuffers::Verifier &verifier)
const {
2787 return VerifyTableStart(verifier) &&
2788 VerifyOffset(verifier,
VT_BASE) &&
2789 verifier.VerifyTable(base()) &&
2790 verifier.EndTable();
2796 flatbuffers::FlatBufferBuilder &
fbb_;
2798 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2803 start_ = fbb_.StartTable();
2807 const auto end = fbb_.EndTable(start_);
2808 auto o = flatbuffers::Offset<CastLayer>(end);
2814 flatbuffers::FlatBufferBuilder &_fbb,
2815 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
2818 return builder_.
Finish();
2821 struct ChannelShuffleLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2823 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2827 const armnnSerializer::LayerBase *
base()
const {
2828 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2830 const armnnSerializer::ChannelShuffleDescriptor *
descriptor()
const {
2831 return GetPointer<const armnnSerializer::ChannelShuffleDescriptor *>(
VT_DESCRIPTOR);
2833 bool Verify(flatbuffers::Verifier &verifier)
const {
2834 return VerifyTableStart(verifier) &&
2835 VerifyOffset(verifier,
VT_BASE) &&
2836 verifier.VerifyTable(base()) &&
2838 verifier.VerifyTable(descriptor()) &&
2839 verifier.EndTable();
2845 flatbuffers::FlatBufferBuilder &
fbb_;
2847 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2850 void add_descriptor(flatbuffers::Offset<armnnSerializer::ChannelShuffleDescriptor> descriptor) {
2855 start_ = fbb_.StartTable();
2858 flatbuffers::Offset<ChannelShuffleLayer>
Finish() {
2859 const auto end = fbb_.EndTable(start_);
2860 auto o = flatbuffers::Offset<ChannelShuffleLayer>(end);
2866 flatbuffers::FlatBufferBuilder &_fbb,
2867 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2868 flatbuffers::Offset<armnnSerializer::ChannelShuffleDescriptor> descriptor = 0) {
2872 return builder_.
Finish();
2875 struct ChannelShuffleDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2877 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2882 return GetField<uint32_t>(
VT_AXIS, 0);
2885 return GetField<uint32_t>(VT_NUMGROUPS, 0);
2887 bool Verify(flatbuffers::Verifier &verifier)
const {
2888 return VerifyTableStart(verifier) &&
2889 VerifyField<uint32_t>(verifier,
VT_AXIS) &&
2890 VerifyField<uint32_t>(verifier, VT_NUMGROUPS) &&
2891 verifier.EndTable();
2897 flatbuffers::FlatBufferBuilder &
fbb_;
2903 fbb_.AddElement<uint32_t>(ChannelShuffleDescriptor::VT_NUMGROUPS, numGroups, 0);
2907 start_ = fbb_.StartTable();
2910 flatbuffers::Offset<ChannelShuffleDescriptor>
Finish() {
2911 const auto end = fbb_.EndTable(start_);
2912 auto o = flatbuffers::Offset<ChannelShuffleDescriptor>(end);
2918 flatbuffers::FlatBufferBuilder &_fbb,
2920 uint32_t numGroups = 0) {
2924 return builder_.
Finish();
2927 struct ComparisonDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2929 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2935 bool Verify(flatbuffers::Verifier &verifier)
const {
2936 return VerifyTableStart(verifier) &&
2937 VerifyField<int8_t>(verifier, VT_OPERATION) &&
2938 verifier.EndTable();
2944 flatbuffers::FlatBufferBuilder &
fbb_;
2947 fbb_.AddElement<int8_t>(ComparisonDescriptor::VT_OPERATION,
static_cast<int8_t
>(operation), 0);
2951 start_ = fbb_.StartTable();
2954 flatbuffers::Offset<ComparisonDescriptor>
Finish() {
2955 const auto end = fbb_.EndTable(start_);
2956 auto o = flatbuffers::Offset<ComparisonDescriptor>(end);
2962 flatbuffers::FlatBufferBuilder &_fbb,
2966 return builder_.
Finish();
2969 struct ComparisonLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2971 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2975 const armnnSerializer::LayerBase *
base()
const {
2976 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2978 const armnnSerializer::ComparisonDescriptor *
descriptor()
const {
2979 return GetPointer<const armnnSerializer::ComparisonDescriptor *>(
VT_DESCRIPTOR);
2981 bool Verify(flatbuffers::Verifier &verifier)
const {
2982 return VerifyTableStart(verifier) &&
2983 VerifyOffset(verifier,
VT_BASE) &&
2984 verifier.VerifyTable(base()) &&
2986 verifier.VerifyTable(descriptor()) &&
2987 verifier.EndTable();
2993 flatbuffers::FlatBufferBuilder &
fbb_;
2995 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2998 void add_descriptor(flatbuffers::Offset<armnnSerializer::ComparisonDescriptor> descriptor) {
3003 start_ = fbb_.StartTable();
3006 flatbuffers::Offset<ComparisonLayer>
Finish() {
3007 const auto end = fbb_.EndTable(start_);
3008 auto o = flatbuffers::Offset<ComparisonLayer>(end);
3014 flatbuffers::FlatBufferBuilder &_fbb,
3015 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3016 flatbuffers::Offset<armnnSerializer::ComparisonDescriptor> descriptor = 0) {
3020 return builder_.
Finish();
3023 struct ConstantLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3025 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3029 const armnnSerializer::LayerBase *
base()
const {
3030 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3032 const armnnSerializer::ConstTensor *
input()
const {
3033 return GetPointer<const armnnSerializer::ConstTensor *>(VT_INPUT);
3035 bool Verify(flatbuffers::Verifier &verifier)
const {
3036 return VerifyTableStart(verifier) &&
3037 VerifyOffset(verifier,
VT_BASE) &&
3038 verifier.VerifyTable(base()) &&
3039 VerifyOffset(verifier, VT_INPUT) &&
3040 verifier.VerifyTable(input()) &&
3041 verifier.EndTable();
3047 flatbuffers::FlatBufferBuilder &
fbb_;
3049 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3052 void add_input(flatbuffers::Offset<armnnSerializer::ConstTensor> input) {
3053 fbb_.AddOffset(ConstantLayer::VT_INPUT, input);
3057 start_ = fbb_.StartTable();
3060 flatbuffers::Offset<ConstantLayer>
Finish() {
3061 const auto end = fbb_.EndTable(start_);
3062 auto o = flatbuffers::Offset<ConstantLayer>(end);
3068 flatbuffers::FlatBufferBuilder &_fbb,
3069 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3070 flatbuffers::Offset<armnnSerializer::ConstTensor> input = 0) {
3074 return builder_.
Finish();
3077 struct Convolution2dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3079 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3085 const armnnSerializer::LayerBase *
base()
const {
3086 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3088 const armnnSerializer::Convolution2dDescriptor *
descriptor()
const {
3089 return GetPointer<const armnnSerializer::Convolution2dDescriptor *>(
VT_DESCRIPTOR);
3091 const armnnSerializer::ConstTensor *
weights()
const {
3092 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_WEIGHTS);
3094 const armnnSerializer::ConstTensor *
biases()
const {
3095 return GetPointer<const armnnSerializer::ConstTensor *>(VT_BIASES);
3097 bool Verify(flatbuffers::Verifier &verifier)
const {
3098 return VerifyTableStart(verifier) &&
3099 VerifyOffset(verifier,
VT_BASE) &&
3100 verifier.VerifyTable(base()) &&
3102 verifier.VerifyTable(descriptor()) &&
3104 verifier.VerifyTable(weights()) &&
3105 VerifyOffset(verifier, VT_BIASES) &&
3106 verifier.VerifyTable(biases()) &&
3107 verifier.EndTable();
3113 flatbuffers::FlatBufferBuilder &
fbb_;
3115 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3118 void add_descriptor(flatbuffers::Offset<armnnSerializer::Convolution2dDescriptor> descriptor) {
3121 void add_weights(flatbuffers::Offset<armnnSerializer::ConstTensor> weights) {
3124 void add_biases(flatbuffers::Offset<armnnSerializer::ConstTensor> biases) {
3125 fbb_.AddOffset(Convolution2dLayer::VT_BIASES, biases);
3129 start_ = fbb_.StartTable();
3132 flatbuffers::Offset<Convolution2dLayer>
Finish() {
3133 const auto end = fbb_.EndTable(start_);
3134 auto o = flatbuffers::Offset<Convolution2dLayer>(end);
3140 flatbuffers::FlatBufferBuilder &_fbb,
3141 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3142 flatbuffers::Offset<armnnSerializer::Convolution2dDescriptor> descriptor = 0,
3143 flatbuffers::Offset<armnnSerializer::ConstTensor> weights = 0,
3144 flatbuffers::Offset<armnnSerializer::ConstTensor> biases = 0) {
3150 return builder_.
Finish();
3153 struct Convolution2dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3155 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3174 return GetField<uint32_t>(
VT_PADTOP, 0);
3197 bool Verify(flatbuffers::Verifier &verifier)
const {
3198 return VerifyTableStart(verifier) &&
3199 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
3201 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
3203 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
3204 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
3209 verifier.EndTable();
3215 flatbuffers::FlatBufferBuilder &
fbb_;
3249 start_ = fbb_.StartTable();
3252 flatbuffers::Offset<Convolution2dDescriptor>
Finish() {
3253 const auto end = fbb_.EndTable(start_);
3254 auto o = flatbuffers::Offset<Convolution2dDescriptor>(end);
3260 flatbuffers::FlatBufferBuilder &_fbb,
3261 uint32_t padLeft = 0,
3262 uint32_t padRight = 0,
3263 uint32_t padTop = 0,
3264 uint32_t padBottom = 0,
3265 uint32_t strideX = 0,
3266 uint32_t strideY = 0,
3267 uint32_t dilationX = 1,
3268 uint32_t dilationY = 1,
3269 bool biasEnabled =
false,
3282 return builder_.
Finish();
3285 struct Convolution3dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3287 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3291 const armnnSerializer::LayerBase *
base()
const {
3292 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3294 const armnnSerializer::Convolution3dDescriptor *
descriptor()
const {
3295 return GetPointer<const armnnSerializer::Convolution3dDescriptor *>(
VT_DESCRIPTOR);
3297 bool Verify(flatbuffers::Verifier &verifier)
const {
3298 return VerifyTableStart(verifier) &&
3299 VerifyOffset(verifier,
VT_BASE) &&
3300 verifier.VerifyTable(base()) &&
3302 verifier.VerifyTable(descriptor()) &&
3303 verifier.EndTable();
3309 flatbuffers::FlatBufferBuilder &
fbb_;
3311 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3314 void add_descriptor(flatbuffers::Offset<armnnSerializer::Convolution3dDescriptor> descriptor) {
3319 start_ = fbb_.StartTable();
3322 flatbuffers::Offset<Convolution3dLayer>
Finish() {
3323 const auto end = fbb_.EndTable(start_);
3324 auto o = flatbuffers::Offset<Convolution3dLayer>(end);
3330 flatbuffers::FlatBufferBuilder &_fbb,
3331 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3332 flatbuffers::Offset<armnnSerializer::Convolution3dDescriptor> descriptor = 0) {
3336 return builder_.
Finish();
3339 struct Convolution3dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3341 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3364 return GetField<uint32_t>(
VT_PADTOP, 0);
3399 bool Verify(flatbuffers::Verifier &verifier)
const {
3400 return VerifyTableStart(verifier) &&
3401 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
3403 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
3406 VerifyField<uint32_t>(verifier,
VT_PADBACK) &&
3407 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
3408 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
3409 VerifyField<uint32_t>(verifier,
VT_STRIDEZ) &&
3415 verifier.EndTable();
3421 flatbuffers::FlatBufferBuilder &
fbb_;
3467 start_ = fbb_.StartTable();
3470 flatbuffers::Offset<Convolution3dDescriptor>
Finish() {
3471 const auto end = fbb_.EndTable(start_);
3472 auto o = flatbuffers::Offset<Convolution3dDescriptor>(end);
3478 flatbuffers::FlatBufferBuilder &_fbb,
3479 uint32_t padLeft = 0,
3480 uint32_t padRight = 0,
3481 uint32_t padTop = 0,
3482 uint32_t padBottom = 0,
3483 uint32_t padFront = 0,
3484 uint32_t padBack = 0,
3485 uint32_t strideX = 0,
3486 uint32_t strideY = 0,
3487 uint32_t strideZ = 0,
3488 uint32_t dilationX = 1,
3489 uint32_t dilationY = 1,
3490 uint32_t dilationZ = 1,
3491 bool biasEnabled =
false,
3508 return builder_.
Finish();
3511 struct DepthToSpaceLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3513 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3517 const armnnSerializer::LayerBase *
base()
const {
3518 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3521 return GetPointer<const armnnSerializer::DepthToSpaceDescriptor *>(
VT_DESCRIPTOR);
3523 bool Verify(flatbuffers::Verifier &verifier)
const {
3524 return VerifyTableStart(verifier) &&
3525 VerifyOffset(verifier,
VT_BASE) &&
3526 verifier.VerifyTable(base()) &&
3528 verifier.VerifyTable(descriptor()) &&
3529 verifier.EndTable();
3535 flatbuffers::FlatBufferBuilder &
fbb_;
3537 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3540 void add_descriptor(flatbuffers::Offset<armnnSerializer::DepthToSpaceDescriptor> descriptor) {
3545 start_ = fbb_.StartTable();
3548 flatbuffers::Offset<DepthToSpaceLayer>
Finish() {
3549 const auto end = fbb_.EndTable(start_);
3550 auto o = flatbuffers::Offset<DepthToSpaceLayer>(end);
3556 flatbuffers::FlatBufferBuilder &_fbb,
3557 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3558 flatbuffers::Offset<armnnSerializer::DepthToSpaceDescriptor> descriptor = 0) {
3562 return builder_.
Finish();
3567 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3577 bool Verify(flatbuffers::Verifier &verifier)
const {
3578 return VerifyTableStart(verifier) &&
3581 verifier.EndTable();
3587 flatbuffers::FlatBufferBuilder &
fbb_;
3597 start_ = fbb_.StartTable();
3600 flatbuffers::Offset<DepthToSpaceDescriptor>
Finish() {
3601 const auto end = fbb_.EndTable(start_);
3602 auto o = flatbuffers::Offset<DepthToSpaceDescriptor>(end);
3608 flatbuffers::FlatBufferBuilder &_fbb,
3609 uint32_t blockSize = 0,
3614 return builder_.
Finish();
3617 struct DivisionLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3619 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3622 const armnnSerializer::LayerBase *
base()
const {
3623 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3625 bool Verify(flatbuffers::Verifier &verifier)
const {
3626 return VerifyTableStart(verifier) &&
3627 VerifyOffset(verifier,
VT_BASE) &&
3628 verifier.VerifyTable(base()) &&
3629 verifier.EndTable();
3635 flatbuffers::FlatBufferBuilder &
fbb_;
3637 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3642 start_ = fbb_.StartTable();
3645 flatbuffers::Offset<DivisionLayer>
Finish() {
3646 const auto end = fbb_.EndTable(start_);
3647 auto o = flatbuffers::Offset<DivisionLayer>(end);
3653 flatbuffers::FlatBufferBuilder &_fbb,
3654 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
3657 return builder_.
Finish();
3660 struct ElementwiseUnaryDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3662 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3668 bool Verify(flatbuffers::Verifier &verifier)
const {
3669 return VerifyTableStart(verifier) &&
3670 VerifyField<int8_t>(verifier, VT_OPERATION) &&
3671 verifier.EndTable();
3676 typedef ElementwiseUnaryDescriptor
Table;
3677 flatbuffers::FlatBufferBuilder &
fbb_;
3680 fbb_.AddElement<int8_t>(ElementwiseUnaryDescriptor::VT_OPERATION,
static_cast<int8_t
>(operation), 0);
3684 start_ = fbb_.StartTable();
3687 flatbuffers::Offset<ElementwiseUnaryDescriptor>
Finish() {
3688 const auto end = fbb_.EndTable(start_);
3689 auto o = flatbuffers::Offset<ElementwiseUnaryDescriptor>(end);
3695 flatbuffers::FlatBufferBuilder &_fbb,
3699 return builder_.
Finish();
3702 struct ElementwiseUnaryLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3704 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3708 const armnnSerializer::LayerBase *
base()
const {
3709 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3711 const armnnSerializer::ElementwiseUnaryDescriptor *
descriptor()
const {
3712 return GetPointer<const armnnSerializer::ElementwiseUnaryDescriptor *>(
VT_DESCRIPTOR);
3714 bool Verify(flatbuffers::Verifier &verifier)
const {
3715 return VerifyTableStart(verifier) &&
3716 VerifyOffset(verifier,
VT_BASE) &&
3717 verifier.VerifyTable(base()) &&
3719 verifier.VerifyTable(descriptor()) &&
3720 verifier.EndTable();
3726 flatbuffers::FlatBufferBuilder &
fbb_;
3728 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3731 void add_descriptor(flatbuffers::Offset<armnnSerializer::ElementwiseUnaryDescriptor> descriptor) {
3736 start_ = fbb_.StartTable();
3739 flatbuffers::Offset<ElementwiseUnaryLayer>
Finish() {
3740 const auto end = fbb_.EndTable(start_);
3741 auto o = flatbuffers::Offset<ElementwiseUnaryLayer>(end);
3747 flatbuffers::FlatBufferBuilder &_fbb,
3748 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3749 flatbuffers::Offset<armnnSerializer::ElementwiseUnaryDescriptor> descriptor = 0) {
3753 return builder_.
Finish();
3757 struct EqualLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3759 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3762 const armnnSerializer::LayerBase *
base()
const {
3763 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3765 bool Verify(flatbuffers::Verifier &verifier)
const {
3766 return VerifyTableStart(verifier) &&
3767 VerifyOffset(verifier,
VT_BASE) &&
3768 verifier.VerifyTable(base()) &&
3769 verifier.EndTable();
3775 flatbuffers::FlatBufferBuilder &
fbb_;
3777 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3782 start_ = fbb_.StartTable();
3786 const auto end = fbb_.EndTable(start_);
3787 auto o = flatbuffers::Offset<EqualLayer>(end);
3793 flatbuffers::FlatBufferBuilder &_fbb,
3794 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
3797 return builder_.
Finish();
3800 struct FillLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3802 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3806 const armnnSerializer::LayerBase *
base()
const {
3807 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3810 return GetPointer<const armnnSerializer::FillDescriptor *>(
VT_DESCRIPTOR);
3812 bool Verify(flatbuffers::Verifier &verifier)
const {
3813 return VerifyTableStart(verifier) &&
3814 VerifyOffset(verifier,
VT_BASE) &&
3815 verifier.VerifyTable(base()) &&
3817 verifier.VerifyTable(descriptor()) &&
3818 verifier.EndTable();
3824 flatbuffers::FlatBufferBuilder &
fbb_;
3826 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3829 void add_descriptor(flatbuffers::Offset<armnnSerializer::FillDescriptor> descriptor) {
3834 start_ = fbb_.StartTable();
3838 const auto end = fbb_.EndTable(start_);
3839 auto o = flatbuffers::Offset<FillLayer>(end);
3845 flatbuffers::FlatBufferBuilder &_fbb,
3846 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3847 flatbuffers::Offset<armnnSerializer::FillDescriptor> descriptor = 0) {
3851 return builder_.
Finish();
3854 struct FillDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3856 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3860 return GetField<float>(VT_VALUE, 0.0f);
3862 bool Verify(flatbuffers::Verifier &verifier)
const {
3863 return VerifyTableStart(verifier) &&
3864 VerifyField<float>(verifier, VT_VALUE) &&
3865 verifier.EndTable();
3871 flatbuffers::FlatBufferBuilder &
fbb_;
3874 fbb_.AddElement<
float>(FillDescriptor::VT_VALUE, value, 0.0f);
3878 start_ = fbb_.StartTable();
3881 flatbuffers::Offset<FillDescriptor>
Finish() {
3882 const auto end = fbb_.EndTable(start_);
3883 auto o = flatbuffers::Offset<FillDescriptor>(end);
3889 flatbuffers::FlatBufferBuilder &_fbb,
3890 float value = 0.0f) {
3893 return builder_.
Finish();
3896 struct FloorLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3898 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3901 const armnnSerializer::LayerBase *
base()
const {
3902 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3904 bool Verify(flatbuffers::Verifier &verifier)
const {
3905 return VerifyTableStart(verifier) &&
3906 VerifyOffset(verifier,
VT_BASE) &&
3907 verifier.VerifyTable(base()) &&
3908 verifier.EndTable();
3914 flatbuffers::FlatBufferBuilder &
fbb_;
3916 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3921 start_ = fbb_.StartTable();
3925 const auto end = fbb_.EndTable(start_);
3926 auto o = flatbuffers::Offset<FloorLayer>(end);
3932 flatbuffers::FlatBufferBuilder &_fbb,
3933 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
3936 return builder_.
Finish();
3939 struct FullyConnectedLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3941 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3947 const armnnSerializer::LayerBase *
base()
const {
3948 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3950 const armnnSerializer::FullyConnectedDescriptor *
descriptor()
const {
3951 return GetPointer<const armnnSerializer::FullyConnectedDescriptor *>(
VT_DESCRIPTOR);
3953 const armnnSerializer::ConstTensor *
weights()
const {
3954 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_WEIGHTS);
3956 const armnnSerializer::ConstTensor *
biases()
const {
3957 return GetPointer<const armnnSerializer::ConstTensor *>(VT_BIASES);
3959 bool Verify(flatbuffers::Verifier &verifier)
const {
3960 return VerifyTableStart(verifier) &&
3961 VerifyOffset(verifier,
VT_BASE) &&
3962 verifier.VerifyTable(base()) &&
3964 verifier.VerifyTable(descriptor()) &&
3966 verifier.VerifyTable(weights()) &&
3967 VerifyOffset(verifier, VT_BIASES) &&
3968 verifier.VerifyTable(biases()) &&
3969 verifier.EndTable();
3975 flatbuffers::FlatBufferBuilder &
fbb_;
3977 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3980 void add_descriptor(flatbuffers::Offset<armnnSerializer::FullyConnectedDescriptor> descriptor) {
3983 void add_weights(flatbuffers::Offset<armnnSerializer::ConstTensor> weights) {
3986 void add_biases(flatbuffers::Offset<armnnSerializer::ConstTensor> biases) {
3987 fbb_.AddOffset(FullyConnectedLayer::VT_BIASES, biases);
3991 start_ = fbb_.StartTable();
3994 flatbuffers::Offset<FullyConnectedLayer>
Finish() {
3995 const auto end = fbb_.EndTable(start_);
3996 auto o = flatbuffers::Offset<FullyConnectedLayer>(end);
4002 flatbuffers::FlatBufferBuilder &_fbb,
4003 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4004 flatbuffers::Offset<armnnSerializer::FullyConnectedDescriptor> descriptor = 0,
4005 flatbuffers::Offset<armnnSerializer::ConstTensor> weights = 0,
4006 flatbuffers::Offset<armnnSerializer::ConstTensor> biases = 0) {
4012 return builder_.
Finish();
4015 struct FullyConnectedDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4017 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4020 VT_CONSTANTWEIGHTS = 8
4029 return GetField<uint8_t>(VT_CONSTANTWEIGHTS, 1) != 0;
4031 bool Verify(flatbuffers::Verifier &verifier)
const {
4032 return VerifyTableStart(verifier) &&
4035 VerifyField<uint8_t>(verifier, VT_CONSTANTWEIGHTS) &&
4036 verifier.EndTable();
4042 flatbuffers::FlatBufferBuilder &
fbb_;
4051 fbb_.AddElement<uint8_t>(FullyConnectedDescriptor::VT_CONSTANTWEIGHTS,
static_cast<uint8_t
>(constantWeights), 1);
4055 start_ = fbb_.StartTable();
4058 flatbuffers::Offset<FullyConnectedDescriptor>
Finish() {
4059 const auto end = fbb_.EndTable(start_);
4060 auto o = flatbuffers::Offset<FullyConnectedDescriptor>(end);
4066 flatbuffers::FlatBufferBuilder &_fbb,
4067 bool biasEnabled =
false,
4068 bool transposeWeightsMatrix =
false,
4069 bool constantWeights =
true) {
4074 return builder_.
Finish();
4077 struct GatherLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4079 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4083 const armnnSerializer::LayerBase *
base()
const {
4084 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4087 return GetPointer<const armnnSerializer::GatherDescriptor *>(
VT_DESCRIPTOR);
4089 bool Verify(flatbuffers::Verifier &verifier)
const {
4090 return VerifyTableStart(verifier) &&
4091 VerifyOffset(verifier,
VT_BASE) &&
4092 verifier.VerifyTable(base()) &&
4094 verifier.VerifyTable(descriptor()) &&
4095 verifier.EndTable();
4101 flatbuffers::FlatBufferBuilder &
fbb_;
4103 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4106 void add_descriptor(flatbuffers::Offset<armnnSerializer::GatherDescriptor> descriptor) {
4111 start_ = fbb_.StartTable();
4115 const auto end = fbb_.EndTable(start_);
4116 auto o = flatbuffers::Offset<GatherLayer>(end);
4122 flatbuffers::FlatBufferBuilder &_fbb,
4123 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4124 flatbuffers::Offset<armnnSerializer::GatherDescriptor> descriptor = 0) {
4128 return builder_.
Finish();
4131 struct GatherDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4133 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4137 return GetField<int32_t>(
VT_AXIS, 0);
4139 bool Verify(flatbuffers::Verifier &verifier)
const {
4140 return VerifyTableStart(verifier) &&
4141 VerifyField<int32_t>(verifier,
VT_AXIS) &&
4142 verifier.EndTable();
4148 flatbuffers::FlatBufferBuilder &
fbb_;
4155 start_ = fbb_.StartTable();
4158 flatbuffers::Offset<GatherDescriptor>
Finish() {
4159 const auto end = fbb_.EndTable(start_);
4160 auto o = flatbuffers::Offset<GatherDescriptor>(end);
4166 flatbuffers::FlatBufferBuilder &_fbb,
4170 return builder_.
Finish();
4174 struct GreaterLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4176 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4179 const armnnSerializer::LayerBase *
base()
const {
4180 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4182 bool Verify(flatbuffers::Verifier &verifier)
const {
4183 return VerifyTableStart(verifier) &&
4184 VerifyOffset(verifier,
VT_BASE) &&
4185 verifier.VerifyTable(base()) &&
4186 verifier.EndTable();
4192 flatbuffers::FlatBufferBuilder &
fbb_;
4194 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4199 start_ = fbb_.StartTable();
4203 const auto end = fbb_.EndTable(start_);
4204 auto o = flatbuffers::Offset<GreaterLayer>(end);
4210 flatbuffers::FlatBufferBuilder &_fbb,
4211 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4214 return builder_.
Finish();
4217 struct InputLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4219 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4222 const armnnSerializer::BindableLayerBase *
base()
const {
4223 return GetPointer<const armnnSerializer::BindableLayerBase *>(
VT_BASE);
4225 bool Verify(flatbuffers::Verifier &verifier)
const {
4226 return VerifyTableStart(verifier) &&
4227 VerifyOffset(verifier,
VT_BASE) &&
4228 verifier.VerifyTable(base()) &&
4229 verifier.EndTable();
4235 flatbuffers::FlatBufferBuilder &
fbb_;
4237 void add_base(flatbuffers::Offset<armnnSerializer::BindableLayerBase> base) {
4242 start_ = fbb_.StartTable();
4246 const auto end = fbb_.EndTable(start_);
4247 auto o = flatbuffers::Offset<InputLayer>(end);
4253 flatbuffers::FlatBufferBuilder &_fbb,
4254 flatbuffers::Offset<armnnSerializer::BindableLayerBase> base = 0) {
4257 return builder_.
Finish();
4260 struct InstanceNormalizationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4262 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4266 const armnnSerializer::LayerBase *
base()
const {
4267 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4269 const armnnSerializer::InstanceNormalizationDescriptor *
descriptor()
const {
4270 return GetPointer<const armnnSerializer::InstanceNormalizationDescriptor *>(
VT_DESCRIPTOR);
4272 bool Verify(flatbuffers::Verifier &verifier)
const {
4273 return VerifyTableStart(verifier) &&
4274 VerifyOffset(verifier,
VT_BASE) &&
4275 verifier.VerifyTable(base()) &&
4277 verifier.VerifyTable(descriptor()) &&
4278 verifier.EndTable();
4283 typedef InstanceNormalizationLayer
Table;
4284 flatbuffers::FlatBufferBuilder &
fbb_;
4286 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4289 void add_descriptor(flatbuffers::Offset<armnnSerializer::InstanceNormalizationDescriptor> descriptor) {
4294 start_ = fbb_.StartTable();
4297 flatbuffers::Offset<InstanceNormalizationLayer>
Finish() {
4298 const auto end = fbb_.EndTable(start_);
4299 auto o = flatbuffers::Offset<InstanceNormalizationLayer>(end);
4305 flatbuffers::FlatBufferBuilder &_fbb,
4306 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4307 flatbuffers::Offset<armnnSerializer::InstanceNormalizationDescriptor> descriptor = 0) {
4311 return builder_.
Finish();
4314 struct InstanceNormalizationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4316 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4323 return GetField<float>(
VT_GAMMA, 0.0f);
4326 return GetField<float>(
VT_BETA, 0.0f);
4329 return GetField<float>(
VT_EPS, 0.0f);
4334 bool Verify(flatbuffers::Verifier &verifier)
const {
4335 return VerifyTableStart(verifier) &&
4336 VerifyField<float>(verifier,
VT_GAMMA) &&
4337 VerifyField<float>(verifier,
VT_BETA) &&
4338 VerifyField<float>(verifier,
VT_EPS) &&
4340 verifier.EndTable();
4345 typedef InstanceNormalizationDescriptor
Table;
4346 flatbuffers::FlatBufferBuilder &
fbb_;
4362 start_ = fbb_.StartTable();
4365 flatbuffers::Offset<InstanceNormalizationDescriptor>
Finish() {
4366 const auto end = fbb_.EndTable(start_);
4367 auto o = flatbuffers::Offset<InstanceNormalizationDescriptor>(end);
4373 flatbuffers::FlatBufferBuilder &_fbb,
4383 return builder_.
Finish();
4386 struct LogSoftmaxLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4388 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4392 const armnnSerializer::LayerBase *
base()
const {
4393 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4396 return GetPointer<const armnnSerializer::LogSoftmaxDescriptor *>(
VT_DESCRIPTOR);
4398 bool Verify(flatbuffers::Verifier &verifier)
const {
4399 return VerifyTableStart(verifier) &&
4400 VerifyOffset(verifier,
VT_BASE) &&
4401 verifier.VerifyTable(base()) &&
4403 verifier.VerifyTable(descriptor()) &&
4404 verifier.EndTable();
4410 flatbuffers::FlatBufferBuilder &
fbb_;
4412 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4415 void add_descriptor(flatbuffers::Offset<armnnSerializer::LogSoftmaxDescriptor> descriptor) {
4420 start_ = fbb_.StartTable();
4423 flatbuffers::Offset<LogSoftmaxLayer>
Finish() {
4424 const auto end = fbb_.EndTable(start_);
4425 auto o = flatbuffers::Offset<LogSoftmaxLayer>(end);
4431 flatbuffers::FlatBufferBuilder &_fbb,
4432 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4433 flatbuffers::Offset<armnnSerializer::LogSoftmaxDescriptor> descriptor = 0) {
4437 return builder_.
Finish();
4442 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4447 return GetField<float>(
VT_BETA, 1.0f);
4450 return GetField<int32_t>(
VT_AXIS, -1);
4452 bool Verify(flatbuffers::Verifier &verifier)
const {
4453 return VerifyTableStart(verifier) &&
4454 VerifyField<float>(verifier,
VT_BETA) &&
4455 VerifyField<int32_t>(verifier,
VT_AXIS) &&
4456 verifier.EndTable();
4462 flatbuffers::FlatBufferBuilder &
fbb_;
4472 start_ = fbb_.StartTable();
4475 flatbuffers::Offset<LogSoftmaxDescriptor>
Finish() {
4476 const auto end = fbb_.EndTable(start_);
4477 auto o = flatbuffers::Offset<LogSoftmaxDescriptor>(end);
4483 flatbuffers::FlatBufferBuilder &_fbb,
4485 int32_t axis = -1) {
4489 return builder_.
Finish();
4492 struct L2NormalizationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4494 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4498 const armnnSerializer::LayerBase *
base()
const {
4499 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4501 const armnnSerializer::L2NormalizationDescriptor *
descriptor()
const {
4502 return GetPointer<const armnnSerializer::L2NormalizationDescriptor *>(
VT_DESCRIPTOR);
4504 bool Verify(flatbuffers::Verifier &verifier)
const {
4505 return VerifyTableStart(verifier) &&
4506 VerifyOffset(verifier,
VT_BASE) &&
4507 verifier.VerifyTable(base()) &&
4509 verifier.VerifyTable(descriptor()) &&
4510 verifier.EndTable();
4516 flatbuffers::FlatBufferBuilder &
fbb_;
4518 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4521 void add_descriptor(flatbuffers::Offset<armnnSerializer::L2NormalizationDescriptor> descriptor) {
4526 start_ = fbb_.StartTable();
4529 flatbuffers::Offset<L2NormalizationLayer>
Finish() {
4530 const auto end = fbb_.EndTable(start_);
4531 auto o = flatbuffers::Offset<L2NormalizationLayer>(end);
4537 flatbuffers::FlatBufferBuilder &_fbb,
4538 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4539 flatbuffers::Offset<armnnSerializer::L2NormalizationDescriptor> descriptor = 0) {
4543 return builder_.
Finish();
4546 struct L2NormalizationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4548 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4556 return GetField<float>(
VT_EPS, 1e-12f);
4558 bool Verify(flatbuffers::Verifier &verifier)
const {
4559 return VerifyTableStart(verifier) &&
4561 VerifyField<float>(verifier,
VT_EPS) &&
4562 verifier.EndTable();
4567 typedef L2NormalizationDescriptor
Table;
4568 flatbuffers::FlatBufferBuilder &
fbb_;
4578 start_ = fbb_.StartTable();
4581 flatbuffers::Offset<L2NormalizationDescriptor>
Finish() {
4582 const auto end = fbb_.EndTable(start_);
4583 auto o = flatbuffers::Offset<L2NormalizationDescriptor>(end);
4589 flatbuffers::FlatBufferBuilder &_fbb,
4591 float eps = 1e-12f) {
4595 return builder_.
Finish();
4598 struct LogicalBinaryDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4600 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4606 bool Verify(flatbuffers::Verifier &verifier)
const {
4607 return VerifyTableStart(verifier) &&
4608 VerifyField<int8_t>(verifier, VT_OPERATION) &&
4609 verifier.EndTable();
4615 flatbuffers::FlatBufferBuilder &
fbb_;
4618 fbb_.AddElement<int8_t>(LogicalBinaryDescriptor::VT_OPERATION,
static_cast<int8_t
>(operation), 0);
4622 start_ = fbb_.StartTable();
4625 flatbuffers::Offset<LogicalBinaryDescriptor>
Finish() {
4626 const auto end = fbb_.EndTable(start_);
4627 auto o = flatbuffers::Offset<LogicalBinaryDescriptor>(end);
4633 flatbuffers::FlatBufferBuilder &_fbb,
4637 return builder_.
Finish();
4640 struct LogicalBinaryLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4642 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4646 const armnnSerializer::LayerBase *
base()
const {
4647 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4649 const armnnSerializer::LogicalBinaryDescriptor *
descriptor()
const {
4650 return GetPointer<const armnnSerializer::LogicalBinaryDescriptor *>(
VT_DESCRIPTOR);
4652 bool Verify(flatbuffers::Verifier &verifier)
const {
4653 return VerifyTableStart(verifier) &&
4654 VerifyOffset(verifier,
VT_BASE) &&
4655 verifier.VerifyTable(base()) &&
4657 verifier.VerifyTable(descriptor()) &&
4658 verifier.EndTable();
4664 flatbuffers::FlatBufferBuilder &
fbb_;
4666 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4669 void add_descriptor(flatbuffers::Offset<armnnSerializer::LogicalBinaryDescriptor> descriptor) {
4674 start_ = fbb_.StartTable();
4677 flatbuffers::Offset<LogicalBinaryLayer>
Finish() {
4678 const auto end = fbb_.EndTable(start_);
4679 auto o = flatbuffers::Offset<LogicalBinaryLayer>(end);
4685 flatbuffers::FlatBufferBuilder &_fbb,
4686 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4687 flatbuffers::Offset<armnnSerializer::LogicalBinaryDescriptor> descriptor = 0) {
4691 return builder_.
Finish();
4694 struct MinimumLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4696 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4699 const armnnSerializer::LayerBase *
base()
const {
4700 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4702 bool Verify(flatbuffers::Verifier &verifier)
const {
4703 return VerifyTableStart(verifier) &&
4704 VerifyOffset(verifier,
VT_BASE) &&
4705 verifier.VerifyTable(base()) &&
4706 verifier.EndTable();
4712 flatbuffers::FlatBufferBuilder &
fbb_;
4714 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4719 start_ = fbb_.StartTable();
4723 const auto end = fbb_.EndTable(start_);
4724 auto o = flatbuffers::Offset<MinimumLayer>(end);
4730 flatbuffers::FlatBufferBuilder &_fbb,
4731 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4734 return builder_.
Finish();
4737 struct MaximumLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4739 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4742 const armnnSerializer::LayerBase *
base()
const {
4743 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4745 bool Verify(flatbuffers::Verifier &verifier)
const {
4746 return VerifyTableStart(verifier) &&
4747 VerifyOffset(verifier,
VT_BASE) &&
4748 verifier.VerifyTable(base()) &&
4749 verifier.EndTable();
4755 flatbuffers::FlatBufferBuilder &
fbb_;
4757 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4762 start_ = fbb_.StartTable();
4766 const auto end = fbb_.EndTable(start_);
4767 auto o = flatbuffers::Offset<MaximumLayer>(end);
4773 flatbuffers::FlatBufferBuilder &_fbb,
4774 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4777 return builder_.
Finish();
4780 struct MultiplicationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4782 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4785 const armnnSerializer::LayerBase *
base()
const {
4786 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4788 bool Verify(flatbuffers::Verifier &verifier)
const {
4789 return VerifyTableStart(verifier) &&
4790 VerifyOffset(verifier,
VT_BASE) &&
4791 verifier.VerifyTable(base()) &&
4792 verifier.EndTable();
4798 flatbuffers::FlatBufferBuilder &
fbb_;
4800 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4805 start_ = fbb_.StartTable();
4808 flatbuffers::Offset<MultiplicationLayer>
Finish() {
4809 const auto end = fbb_.EndTable(start_);
4810 auto o = flatbuffers::Offset<MultiplicationLayer>(end);
4816 flatbuffers::FlatBufferBuilder &_fbb,
4817 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4820 return builder_.
Finish();
4823 struct Pooling2dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4825 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4829 const armnnSerializer::LayerBase *
base()
const {
4830 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4833 return GetPointer<const armnnSerializer::Pooling2dDescriptor *>(
VT_DESCRIPTOR);
4835 bool Verify(flatbuffers::Verifier &verifier)
const {
4836 return VerifyTableStart(verifier) &&
4837 VerifyOffset(verifier,
VT_BASE) &&
4838 verifier.VerifyTable(base()) &&
4840 verifier.VerifyTable(descriptor()) &&
4841 verifier.EndTable();
4847 flatbuffers::FlatBufferBuilder &
fbb_;
4849 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4852 void add_descriptor(flatbuffers::Offset<armnnSerializer::Pooling2dDescriptor> descriptor) {
4857 start_ = fbb_.StartTable();
4860 flatbuffers::Offset<Pooling2dLayer>
Finish() {
4861 const auto end = fbb_.EndTable(start_);
4862 auto o = flatbuffers::Offset<Pooling2dLayer>(end);
4868 flatbuffers::FlatBufferBuilder &_fbb,
4869 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4870 flatbuffers::Offset<armnnSerializer::Pooling2dDescriptor> descriptor = 0) {
4874 return builder_.
Finish();
4877 struct Pooling2dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4879 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4903 return GetField<uint32_t>(
VT_PADTOP, 0);
4929 bool Verify(flatbuffers::Verifier &verifier)
const {
4930 return VerifyTableStart(verifier) &&
4932 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
4934 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
4938 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
4939 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
4943 verifier.EndTable();
4949 flatbuffers::FlatBufferBuilder &
fbb_;
4989 start_ = fbb_.StartTable();
4992 flatbuffers::Offset<Pooling2dDescriptor>
Finish() {
4993 const auto end = fbb_.EndTable(start_);
4994 auto o = flatbuffers::Offset<Pooling2dDescriptor>(end);
5000 flatbuffers::FlatBufferBuilder &_fbb,
5002 uint32_t padLeft = 0,
5003 uint32_t padRight = 0,
5004 uint32_t padTop = 0,
5005 uint32_t padBottom = 0,
5006 uint32_t poolWidth = 0,
5007 uint32_t poolHeight = 0,
5008 uint32_t strideX = 0,
5009 uint32_t strideY = 0,
5026 return builder_.
Finish();
5029 struct QuantizeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5031 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5034 const armnnSerializer::LayerBase *
base()
const {
5035 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5037 bool Verify(flatbuffers::Verifier &verifier)
const {
5038 return VerifyTableStart(verifier) &&
5039 VerifyOffset(verifier,
VT_BASE) &&
5040 verifier.VerifyTable(base()) &&
5041 verifier.EndTable();
5047 flatbuffers::FlatBufferBuilder &
fbb_;
5049 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5054 start_ = fbb_.StartTable();
5057 flatbuffers::Offset<QuantizeLayer>
Finish() {
5058 const auto end = fbb_.EndTable(start_);
5059 auto o = flatbuffers::Offset<QuantizeLayer>(end);
5065 flatbuffers::FlatBufferBuilder &_fbb,
5066 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
5069 return builder_.
Finish();
5072 struct SoftmaxLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5074 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5078 const armnnSerializer::LayerBase *
base()
const {
5079 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5082 return GetPointer<const armnnSerializer::SoftmaxDescriptor *>(
VT_DESCRIPTOR);
5084 bool Verify(flatbuffers::Verifier &verifier)
const {
5085 return VerifyTableStart(verifier) &&
5086 VerifyOffset(verifier,
VT_BASE) &&
5087 verifier.VerifyTable(base()) &&
5089 verifier.VerifyTable(descriptor()) &&
5090 verifier.EndTable();
5096 flatbuffers::FlatBufferBuilder &
fbb_;
5098 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5101 void add_descriptor(flatbuffers::Offset<armnnSerializer::SoftmaxDescriptor> descriptor) {
5106 start_ = fbb_.StartTable();
5110 const auto end = fbb_.EndTable(start_);
5111 auto o = flatbuffers::Offset<SoftmaxLayer>(end);
5117 flatbuffers::FlatBufferBuilder &_fbb,
5118 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5119 flatbuffers::Offset<armnnSerializer::SoftmaxDescriptor> descriptor = 0) {
5123 return builder_.
Finish();
5126 struct SoftmaxDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5128 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5133 return GetField<float>(
VT_BETA, 0.0f);
5136 return GetField<int32_t>(
VT_AXIS, -1);
5138 bool Verify(flatbuffers::Verifier &verifier)
const {
5139 return VerifyTableStart(verifier) &&
5140 VerifyField<float>(verifier,
VT_BETA) &&
5141 VerifyField<int32_t>(verifier,
VT_AXIS) &&
5142 verifier.EndTable();
5148 flatbuffers::FlatBufferBuilder &
fbb_;
5158 start_ = fbb_.StartTable();
5161 flatbuffers::Offset<SoftmaxDescriptor>
Finish() {
5162 const auto end = fbb_.EndTable(start_);
5163 auto o = flatbuffers::Offset<SoftmaxDescriptor>(end);
5169 flatbuffers::FlatBufferBuilder &_fbb,
5171 int32_t axis = -1) {
5175 return builder_.
Finish();
5178 struct DepthwiseConvolution2dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5180 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5186 const armnnSerializer::LayerBase *
base()
const {
5187 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5189 const armnnSerializer::DepthwiseConvolution2dDescriptor *
descriptor()
const {
5190 return GetPointer<const armnnSerializer::DepthwiseConvolution2dDescriptor *>(
VT_DESCRIPTOR);
5192 const armnnSerializer::ConstTensor *
weights()
const {
5193 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_WEIGHTS);
5195 const armnnSerializer::ConstTensor *
biases()
const {
5196 return GetPointer<const armnnSerializer::ConstTensor *>(VT_BIASES);
5198 bool Verify(flatbuffers::Verifier &verifier)
const {
5199 return VerifyTableStart(verifier) &&
5200 VerifyOffset(verifier,
VT_BASE) &&
5201 verifier.VerifyTable(base()) &&
5203 verifier.VerifyTable(descriptor()) &&
5205 verifier.VerifyTable(weights()) &&
5206 VerifyOffset(verifier, VT_BIASES) &&
5207 verifier.VerifyTable(biases()) &&
5208 verifier.EndTable();
5213 typedef DepthwiseConvolution2dLayer
Table;
5214 flatbuffers::FlatBufferBuilder &
fbb_;
5216 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5219 void add_descriptor(flatbuffers::Offset<armnnSerializer::DepthwiseConvolution2dDescriptor> descriptor) {
5222 void add_weights(flatbuffers::Offset<armnnSerializer::ConstTensor> weights) {
5225 void add_biases(flatbuffers::Offset<armnnSerializer::ConstTensor> biases) {
5226 fbb_.AddOffset(DepthwiseConvolution2dLayer::VT_BIASES, biases);
5230 start_ = fbb_.StartTable();
5233 flatbuffers::Offset<DepthwiseConvolution2dLayer>
Finish() {
5234 const auto end = fbb_.EndTable(start_);
5235 auto o = flatbuffers::Offset<DepthwiseConvolution2dLayer>(end);
5241 flatbuffers::FlatBufferBuilder &_fbb,
5242 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5243 flatbuffers::Offset<armnnSerializer::DepthwiseConvolution2dDescriptor> descriptor = 0,
5244 flatbuffers::Offset<armnnSerializer::ConstTensor> weights = 0,
5245 flatbuffers::Offset<armnnSerializer::ConstTensor> biases = 0) {
5251 return builder_.
Finish();
5254 struct DepthwiseConvolution2dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5256 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5275 return GetField<uint32_t>(
VT_PADTOP, 0);
5298 bool Verify(flatbuffers::Verifier &verifier)
const {
5299 return VerifyTableStart(verifier) &&
5300 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
5302 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
5304 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
5305 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
5310 verifier.EndTable();
5315 typedef DepthwiseConvolution2dDescriptor
Table;
5316 flatbuffers::FlatBufferBuilder &
fbb_;
5350 start_ = fbb_.StartTable();
5353 flatbuffers::Offset<DepthwiseConvolution2dDescriptor>
Finish() {
5354 const auto end = fbb_.EndTable(start_);
5355 auto o = flatbuffers::Offset<DepthwiseConvolution2dDescriptor>(end);
5361 flatbuffers::FlatBufferBuilder &_fbb,
5362 uint32_t padLeft = 0,
5363 uint32_t padRight = 0,
5364 uint32_t padTop = 0,
5365 uint32_t padBottom = 0,
5366 uint32_t strideX = 0,
5367 uint32_t strideY = 0,
5368 uint32_t dilationX = 1,
5369 uint32_t dilationY = 1,
5370 bool biasEnabled =
false,
5383 return builder_.
Finish();
5386 struct OutputLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5388 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5391 const armnnSerializer::BindableLayerBase *
base()
const {
5392 return GetPointer<const armnnSerializer::BindableLayerBase *>(
VT_BASE);
5394 bool Verify(flatbuffers::Verifier &verifier)
const {
5395 return VerifyTableStart(verifier) &&
5396 VerifyOffset(verifier,
VT_BASE) &&
5397 verifier.VerifyTable(base()) &&
5398 verifier.EndTable();
5404 flatbuffers::FlatBufferBuilder &
fbb_;
5406 void add_base(flatbuffers::Offset<armnnSerializer::BindableLayerBase> base) {
5411 start_ = fbb_.StartTable();
5415 const auto end = fbb_.EndTable(start_);
5416 auto o = flatbuffers::Offset<OutputLayer>(end);
5422 flatbuffers::FlatBufferBuilder &_fbb,
5423 flatbuffers::Offset<armnnSerializer::BindableLayerBase> base = 0) {
5426 return builder_.
Finish();
5429 struct ReshapeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5431 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5435 const armnnSerializer::LayerBase *
base()
const {
5436 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5439 return GetPointer<const armnnSerializer::ReshapeDescriptor *>(
VT_DESCRIPTOR);
5441 bool Verify(flatbuffers::Verifier &verifier)
const {
5442 return VerifyTableStart(verifier) &&
5443 VerifyOffset(verifier,
VT_BASE) &&
5444 verifier.VerifyTable(base()) &&
5446 verifier.VerifyTable(descriptor()) &&
5447 verifier.EndTable();
5453 flatbuffers::FlatBufferBuilder &
fbb_;
5455 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5458 void add_descriptor(flatbuffers::Offset<armnnSerializer::ReshapeDescriptor> descriptor) {
5463 start_ = fbb_.StartTable();
5467 const auto end = fbb_.EndTable(start_);
5468 auto o = flatbuffers::Offset<ReshapeLayer>(end);
5474 flatbuffers::FlatBufferBuilder &_fbb,
5475 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5476 flatbuffers::Offset<armnnSerializer::ReshapeDescriptor> descriptor = 0) {
5480 return builder_.
Finish();
5483 struct ReshapeDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5485 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5489 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_TARGETSHAPE);
5491 bool Verify(flatbuffers::Verifier &verifier)
const {
5492 return VerifyTableStart(verifier) &&
5493 VerifyOffset(verifier, VT_TARGETSHAPE) &&
5494 verifier.VerifyVector(targetShape()) &&
5495 verifier.EndTable();
5501 flatbuffers::FlatBufferBuilder &
fbb_;
5504 fbb_.AddOffset(ReshapeDescriptor::VT_TARGETSHAPE, targetShape);
5508 start_ = fbb_.StartTable();
5511 flatbuffers::Offset<ReshapeDescriptor>
Finish() {
5512 const auto end = fbb_.EndTable(start_);
5513 auto o = flatbuffers::Offset<ReshapeDescriptor>(end);
5519 flatbuffers::FlatBufferBuilder &_fbb,
5523 return builder_.
Finish();
5527 flatbuffers::FlatBufferBuilder &_fbb,
5528 const std::vector<uint32_t> *targetShape =
nullptr) {
5529 auto targetShape__ = targetShape ? _fbb.CreateVector<uint32_t>(*targetShape) : 0;
5535 struct PermuteLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5537 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5541 const armnnSerializer::LayerBase *
base()
const {
5542 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5545 return GetPointer<const armnnSerializer::PermuteDescriptor *>(
VT_DESCRIPTOR);
5547 bool Verify(flatbuffers::Verifier &verifier)
const {
5548 return VerifyTableStart(verifier) &&
5549 VerifyOffset(verifier,
VT_BASE) &&
5550 verifier.VerifyTable(base()) &&
5552 verifier.VerifyTable(descriptor()) &&
5553 verifier.EndTable();
5559 flatbuffers::FlatBufferBuilder &
fbb_;
5561 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5564 void add_descriptor(flatbuffers::Offset<armnnSerializer::PermuteDescriptor> descriptor) {
5569 start_ = fbb_.StartTable();
5573 const auto end = fbb_.EndTable(start_);
5574 auto o = flatbuffers::Offset<PermuteLayer>(end);
5580 flatbuffers::FlatBufferBuilder &_fbb,
5581 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5582 flatbuffers::Offset<armnnSerializer::PermuteDescriptor> descriptor = 0) {
5586 return builder_.
Finish();
5589 struct PermuteDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5591 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5595 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DIMMAPPINGS);
5597 bool Verify(flatbuffers::Verifier &verifier)
const {
5598 return VerifyTableStart(verifier) &&
5599 VerifyOffset(verifier, VT_DIMMAPPINGS) &&
5600 verifier.VerifyVector(dimMappings()) &&
5601 verifier.EndTable();
5607 flatbuffers::FlatBufferBuilder &
fbb_;
5610 fbb_.AddOffset(PermuteDescriptor::VT_DIMMAPPINGS, dimMappings);
5614 start_ = fbb_.StartTable();
5617 flatbuffers::Offset<PermuteDescriptor>
Finish() {
5618 const auto end = fbb_.EndTable(start_);
5619 auto o = flatbuffers::Offset<PermuteDescriptor>(end);
5625 flatbuffers::FlatBufferBuilder &_fbb,
5629 return builder_.
Finish();
5633 flatbuffers::FlatBufferBuilder &_fbb,
5634 const std::vector<uint32_t> *dimMappings =
nullptr) {
5635 auto dimMappings__ = dimMappings ? _fbb.CreateVector<uint32_t>(*dimMappings) : 0;
5641 struct ShapeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5643 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5646 const armnnSerializer::LayerBase *
base()
const {
5647 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5649 bool Verify(flatbuffers::Verifier &verifier)
const {
5650 return VerifyTableStart(verifier) &&
5651 VerifyOffset(verifier,
VT_BASE) &&
5652 verifier.VerifyTable(base()) &&
5653 verifier.EndTable();
5659 flatbuffers::FlatBufferBuilder &
fbb_;
5661 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5666 start_ = fbb_.StartTable();
5670 const auto end = fbb_.EndTable(start_);
5671 auto o = flatbuffers::Offset<ShapeLayer>(end);
5677 flatbuffers::FlatBufferBuilder &_fbb,
5678 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
5681 return builder_.
Finish();
5684 struct SpaceToBatchNdLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5686 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5690 const armnnSerializer::LayerBase *
base()
const {
5691 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5693 const armnnSerializer::SpaceToBatchNdDescriptor *
descriptor()
const {
5694 return GetPointer<const armnnSerializer::SpaceToBatchNdDescriptor *>(
VT_DESCRIPTOR);
5696 bool Verify(flatbuffers::Verifier &verifier)
const {
5697 return VerifyTableStart(verifier) &&
5698 VerifyOffset(verifier,
VT_BASE) &&
5699 verifier.VerifyTable(base()) &&
5701 verifier.VerifyTable(descriptor()) &&
5702 verifier.EndTable();
5708 flatbuffers::FlatBufferBuilder &
fbb_;
5710 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5713 void add_descriptor(flatbuffers::Offset<armnnSerializer::SpaceToBatchNdDescriptor> descriptor) {
5718 start_ = fbb_.StartTable();
5721 flatbuffers::Offset<SpaceToBatchNdLayer>
Finish() {
5722 const auto end = fbb_.EndTable(start_);
5723 auto o = flatbuffers::Offset<SpaceToBatchNdLayer>(end);
5729 flatbuffers::FlatBufferBuilder &_fbb,
5730 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5731 flatbuffers::Offset<armnnSerializer::SpaceToBatchNdDescriptor> descriptor = 0) {
5735 return builder_.
Finish();
5738 struct SpaceToBatchNdDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5740 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5746 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_BLOCKSHAPE);
5748 const flatbuffers::Vector<uint32_t> *
padList()
const {
5749 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_PADLIST);
5754 bool Verify(flatbuffers::Verifier &verifier)
const {
5755 return VerifyTableStart(verifier) &&
5757 verifier.VerifyVector(blockShape()) &&
5759 verifier.VerifyVector(padList()) &&
5761 verifier.EndTable();
5767 flatbuffers::FlatBufferBuilder &
fbb_;
5780 start_ = fbb_.StartTable();
5783 flatbuffers::Offset<SpaceToBatchNdDescriptor>
Finish() {
5784 const auto end = fbb_.EndTable(start_);
5785 auto o = flatbuffers::Offset<SpaceToBatchNdDescriptor>(end);
5791 flatbuffers::FlatBufferBuilder &_fbb,
5799 return builder_.
Finish();
5803 flatbuffers::FlatBufferBuilder &_fbb,
5804 const std::vector<uint32_t> *blockShape =
nullptr,
5805 const std::vector<uint32_t> *padList =
nullptr,
5807 auto blockShape__ = blockShape ? _fbb.CreateVector<uint32_t>(*blockShape) : 0;
5808 auto padList__ = padList ? _fbb.CreateVector<uint32_t>(*padList) : 0;
5816 struct SpaceToDepthLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5818 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5822 const armnnSerializer::LayerBase *
base()
const {
5823 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5825 const armnnSerializer::SpaceToDepthDescriptor *
descriptor()
const {
5826 return GetPointer<const armnnSerializer::SpaceToDepthDescriptor *>(
VT_DESCRIPTOR);
5828 bool Verify(flatbuffers::Verifier &verifier)
const {
5829 return VerifyTableStart(verifier) &&
5830 VerifyOffset(verifier,
VT_BASE) &&
5831 verifier.VerifyTable(base()) &&
5833 verifier.VerifyTable(descriptor()) &&
5834 verifier.EndTable();
5840 flatbuffers::FlatBufferBuilder &
fbb_;
5842 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5845 void add_descriptor(flatbuffers::Offset<armnnSerializer::SpaceToDepthDescriptor> descriptor) {
5850 start_ = fbb_.StartTable();
5853 flatbuffers::Offset<SpaceToDepthLayer>
Finish() {
5854 const auto end = fbb_.EndTable(start_);
5855 auto o = flatbuffers::Offset<SpaceToDepthLayer>(end);
5861 flatbuffers::FlatBufferBuilder &_fbb,
5862 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5863 flatbuffers::Offset<armnnSerializer::SpaceToDepthDescriptor> descriptor = 0) {
5867 return builder_.
Finish();
5870 struct SpaceToDepthDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5872 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5882 bool Verify(flatbuffers::Verifier &verifier)
const {
5883 return VerifyTableStart(verifier) &&
5886 verifier.EndTable();
5892 flatbuffers::FlatBufferBuilder &
fbb_;
5902 start_ = fbb_.StartTable();
5905 flatbuffers::Offset<SpaceToDepthDescriptor>
Finish() {
5906 const auto end = fbb_.EndTable(start_);
5907 auto o = flatbuffers::Offset<SpaceToDepthDescriptor>(end);
5913 flatbuffers::FlatBufferBuilder &_fbb,
5914 uint32_t blockSize = 0,
5919 return builder_.
Finish();
5922 struct SubtractionLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5924 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5927 const armnnSerializer::LayerBase *
base()
const {
5928 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5930 bool Verify(flatbuffers::Verifier &verifier)
const {
5931 return VerifyTableStart(verifier) &&
5932 VerifyOffset(verifier,
VT_BASE) &&
5933 verifier.VerifyTable(base()) &&
5934 verifier.EndTable();
5940 flatbuffers::FlatBufferBuilder &
fbb_;
5942 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5947 start_ = fbb_.StartTable();
5950 flatbuffers::Offset<SubtractionLayer>
Finish() {
5951 const auto end = fbb_.EndTable(start_);
5952 auto o = flatbuffers::Offset<SubtractionLayer>(end);
5958 flatbuffers::FlatBufferBuilder &_fbb,
5959 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
5962 return builder_.
Finish();
5965 struct BatchToSpaceNdLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5967 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5971 const armnnSerializer::LayerBase *
base()
const {
5972 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5974 const armnnSerializer::BatchToSpaceNdDescriptor *
descriptor()
const {
5975 return GetPointer<const armnnSerializer::BatchToSpaceNdDescriptor *>(
VT_DESCRIPTOR);
5977 bool Verify(flatbuffers::Verifier &verifier)
const {
5978 return VerifyTableStart(verifier) &&
5979 VerifyOffset(verifier,
VT_BASE) &&
5980 verifier.VerifyTable(base()) &&
5982 verifier.VerifyTable(descriptor()) &&
5983 verifier.EndTable();
5989 flatbuffers::FlatBufferBuilder &
fbb_;
5991 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5994 void add_descriptor(flatbuffers::Offset<armnnSerializer::BatchToSpaceNdDescriptor> descriptor) {
5999 start_ = fbb_.StartTable();
6002 flatbuffers::Offset<BatchToSpaceNdLayer>
Finish() {
6003 const auto end = fbb_.EndTable(start_);
6004 auto o = flatbuffers::Offset<BatchToSpaceNdLayer>(end);
6010 flatbuffers::FlatBufferBuilder &_fbb,
6011 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6012 flatbuffers::Offset<armnnSerializer::BatchToSpaceNdDescriptor> descriptor = 0) {
6016 return builder_.
Finish();
6019 struct BatchToSpaceNdDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6021 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6027 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_BLOCKSHAPE);
6029 const flatbuffers::Vector<uint32_t> *
crops()
const {
6030 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_CROPS);
6035 bool Verify(flatbuffers::Verifier &verifier)
const {
6036 return VerifyTableStart(verifier) &&
6038 verifier.VerifyVector(blockShape()) &&
6039 VerifyOffset(verifier,
VT_CROPS) &&
6040 verifier.VerifyVector(crops()) &&
6042 verifier.EndTable();
6048 flatbuffers::FlatBufferBuilder &
fbb_;
6061 start_ = fbb_.StartTable();
6064 flatbuffers::Offset<BatchToSpaceNdDescriptor>
Finish() {
6065 const auto end = fbb_.EndTable(start_);
6066 auto o = flatbuffers::Offset<BatchToSpaceNdDescriptor>(end);
6072 flatbuffers::FlatBufferBuilder &_fbb,
6080 return builder_.
Finish();
6084 flatbuffers::FlatBufferBuilder &_fbb,
6085 const std::vector<uint32_t> *blockShape =
nullptr,
6086 const std::vector<uint32_t> *crops =
nullptr,
6088 auto blockShape__ = blockShape ? _fbb.CreateVector<uint32_t>(*blockShape) : 0;
6089 auto crops__ = crops ? _fbb.CreateVector<uint32_t>(*crops) : 0;
6097 struct NormalizationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6099 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6103 const armnnSerializer::LayerBase *
base()
const {
6104 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6106 const armnnSerializer::NormalizationDescriptor *
descriptor()
const {
6107 return GetPointer<const armnnSerializer::NormalizationDescriptor *>(
VT_DESCRIPTOR);
6109 bool Verify(flatbuffers::Verifier &verifier)
const {
6110 return VerifyTableStart(verifier) &&
6111 VerifyOffset(verifier,
VT_BASE) &&
6112 verifier.VerifyTable(base()) &&
6114 verifier.VerifyTable(descriptor()) &&
6115 verifier.EndTable();
6121 flatbuffers::FlatBufferBuilder &
fbb_;
6123 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6126 void add_descriptor(flatbuffers::Offset<armnnSerializer::NormalizationDescriptor> descriptor) {
6131 start_ = fbb_.StartTable();
6134 flatbuffers::Offset<NormalizationLayer>
Finish() {
6135 const auto end = fbb_.EndTable(start_);
6136 auto o = flatbuffers::Offset<NormalizationLayer>(end);
6142 flatbuffers::FlatBufferBuilder &_fbb,
6143 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6144 flatbuffers::Offset<armnnSerializer::NormalizationDescriptor> descriptor = 0) {
6148 return builder_.
Finish();
6151 struct NormalizationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6153 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6172 return GetField<float>(
VT_ALPHA, 0.0f);
6175 return GetField<float>(
VT_BETA, 0.0f);
6178 return GetField<float>(
VT_K, 0.0f);
6183 bool Verify(flatbuffers::Verifier &verifier)
const {
6184 return VerifyTableStart(verifier) &&
6188 VerifyField<float>(verifier,
VT_ALPHA) &&
6189 VerifyField<float>(verifier,
VT_BETA) &&
6190 VerifyField<float>(verifier,
VT_K) &&
6192 verifier.EndTable();
6198 flatbuffers::FlatBufferBuilder &
fbb_;
6223 start_ = fbb_.StartTable();
6226 flatbuffers::Offset<NormalizationDescriptor>
Finish() {
6227 const auto end = fbb_.EndTable(start_);
6228 auto o = flatbuffers::Offset<NormalizationDescriptor>(end);
6234 flatbuffers::FlatBufferBuilder &_fbb,
6237 uint32_t normSize = 0,
6250 return builder_.
Finish();
6253 struct MeanLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6255 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6259 const armnnSerializer::LayerBase *
base()
const {
6260 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6263 return GetPointer<const armnnSerializer::MeanDescriptor *>(
VT_DESCRIPTOR);
6265 bool Verify(flatbuffers::Verifier &verifier)
const {
6266 return VerifyTableStart(verifier) &&
6267 VerifyOffset(verifier,
VT_BASE) &&
6268 verifier.VerifyTable(base()) &&
6270 verifier.VerifyTable(descriptor()) &&
6271 verifier.EndTable();
6277 flatbuffers::FlatBufferBuilder &
fbb_;
6279 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6282 void add_descriptor(flatbuffers::Offset<armnnSerializer::MeanDescriptor> descriptor) {
6287 start_ = fbb_.StartTable();
6291 const auto end = fbb_.EndTable(start_);
6292 auto o = flatbuffers::Offset<MeanLayer>(end);
6298 flatbuffers::FlatBufferBuilder &_fbb,
6299 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6300 flatbuffers::Offset<armnnSerializer::MeanDescriptor> descriptor = 0) {
6304 return builder_.
Finish();
6307 struct MeanDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6309 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6313 const flatbuffers::Vector<uint32_t> *
axis()
const {
6314 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_AXIS);
6319 bool Verify(flatbuffers::Verifier &verifier)
const {
6320 return VerifyTableStart(verifier) &&
6321 VerifyOffset(verifier,
VT_AXIS) &&
6322 verifier.VerifyVector(axis()) &&
6324 verifier.EndTable();
6330 flatbuffers::FlatBufferBuilder &
fbb_;
6340 start_ = fbb_.StartTable();
6343 flatbuffers::Offset<MeanDescriptor>
Finish() {
6344 const auto end = fbb_.EndTable(start_);
6345 auto o = flatbuffers::Offset<MeanDescriptor>(end);
6351 flatbuffers::FlatBufferBuilder &_fbb,
6353 bool keepDims =
false) {
6357 return builder_.
Finish();
6361 flatbuffers::FlatBufferBuilder &_fbb,
6362 const std::vector<uint32_t> *axis =
nullptr,
6363 bool keepDims =
false) {
6364 auto axis__ = axis ? _fbb.CreateVector<uint32_t>(*axis) : 0;
6371 struct PadLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6373 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6377 const armnnSerializer::LayerBase *
base()
const {
6378 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6381 return GetPointer<const armnnSerializer::PadDescriptor *>(
VT_DESCRIPTOR);
6383 bool Verify(flatbuffers::Verifier &verifier)
const {
6384 return VerifyTableStart(verifier) &&
6385 VerifyOffset(verifier,
VT_BASE) &&
6386 verifier.VerifyTable(base()) &&
6388 verifier.VerifyTable(descriptor()) &&
6389 verifier.EndTable();
6395 flatbuffers::FlatBufferBuilder &
fbb_;
6397 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6400 void add_descriptor(flatbuffers::Offset<armnnSerializer::PadDescriptor> descriptor) {
6405 start_ = fbb_.StartTable();
6409 const auto end = fbb_.EndTable(start_);
6410 auto o = flatbuffers::Offset<PadLayer>(end);
6416 flatbuffers::FlatBufferBuilder &_fbb,
6417 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6418 flatbuffers::Offset<armnnSerializer::PadDescriptor> descriptor = 0) {
6422 return builder_.
Finish();
6425 struct PadDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6427 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6432 const flatbuffers::Vector<uint32_t> *
padList()
const {
6433 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_PADLIST);
6441 bool Verify(flatbuffers::Verifier &verifier)
const {
6442 return VerifyTableStart(verifier) &&
6444 verifier.VerifyVector(padList()) &&
6446 VerifyField<int8_t>(verifier, VT_PADDINGMODE) &&
6447 verifier.EndTable();
6453 flatbuffers::FlatBufferBuilder &
fbb_;
6462 fbb_.AddElement<int8_t>(PadDescriptor::VT_PADDINGMODE,
static_cast<int8_t
>(paddingMode), 0);
6466 start_ = fbb_.StartTable();
6469 flatbuffers::Offset<PadDescriptor>
Finish() {
6470 const auto end = fbb_.EndTable(start_);
6471 auto o = flatbuffers::Offset<PadDescriptor>(end);
6477 flatbuffers::FlatBufferBuilder &_fbb,
6479 float padValue = 0.0f,
6485 return builder_.
Finish();
6489 flatbuffers::FlatBufferBuilder &_fbb,
6490 const std::vector<uint32_t> *padList =
nullptr,
6491 float padValue = 0.0f,
6493 auto padList__ = padList ? _fbb.CreateVector<uint32_t>(*padList) : 0;
6502 struct RsqrtLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6504 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6507 const armnnSerializer::LayerBase *
base()
const {
6508 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6510 bool Verify(flatbuffers::Verifier &verifier)
const {
6511 return VerifyTableStart(verifier) &&
6512 VerifyOffset(verifier,
VT_BASE) &&
6513 verifier.VerifyTable(base()) &&
6514 verifier.EndTable();
6520 flatbuffers::FlatBufferBuilder &
fbb_;
6522 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6527 start_ = fbb_.StartTable();
6531 const auto end = fbb_.EndTable(start_);
6532 auto o = flatbuffers::Offset<RsqrtLayer>(end);
6538 flatbuffers::FlatBufferBuilder &_fbb,
6539 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
6542 return builder_.
Finish();
6545 struct BatchNormalizationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6547 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6555 const armnnSerializer::LayerBase *
base()
const {
6556 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6558 const armnnSerializer::BatchNormalizationDescriptor *
descriptor()
const {
6559 return GetPointer<const armnnSerializer::BatchNormalizationDescriptor *>(
VT_DESCRIPTOR);
6561 const armnnSerializer::ConstTensor *
mean()
const {
6562 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_MEAN);
6565 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_VARIANCE);
6567 const armnnSerializer::ConstTensor *
beta()
const {
6568 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_BETA);
6570 const armnnSerializer::ConstTensor *
gamma()
const {
6571 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_GAMMA);
6573 bool Verify(flatbuffers::Verifier &verifier)
const {
6574 return VerifyTableStart(verifier) &&
6575 VerifyOffset(verifier,
VT_BASE) &&
6576 verifier.VerifyTable(base()) &&
6578 verifier.VerifyTable(descriptor()) &&
6579 VerifyOffset(verifier,
VT_MEAN) &&
6580 verifier.VerifyTable(mean()) &&
6582 verifier.VerifyTable(variance()) &&
6583 VerifyOffset(verifier,
VT_BETA) &&
6584 verifier.VerifyTable(beta()) &&
6585 VerifyOffset(verifier,
VT_GAMMA) &&
6586 verifier.VerifyTable(gamma()) &&
6587 verifier.EndTable();
6593 flatbuffers::FlatBufferBuilder &
fbb_;
6595 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6598 void add_descriptor(flatbuffers::Offset<armnnSerializer::BatchNormalizationDescriptor> descriptor) {
6601 void add_mean(flatbuffers::Offset<armnnSerializer::ConstTensor> mean) {
6604 void add_variance(flatbuffers::Offset<armnnSerializer::ConstTensor> variance) {
6607 void add_beta(flatbuffers::Offset<armnnSerializer::ConstTensor> beta) {
6610 void add_gamma(flatbuffers::Offset<armnnSerializer::ConstTensor> gamma) {
6615 start_ = fbb_.StartTable();
6618 flatbuffers::Offset<BatchNormalizationLayer>
Finish() {
6619 const auto end = fbb_.EndTable(start_);
6620 auto o = flatbuffers::Offset<BatchNormalizationLayer>(end);
6626 flatbuffers::FlatBufferBuilder &_fbb,
6627 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6628 flatbuffers::Offset<armnnSerializer::BatchNormalizationDescriptor> descriptor = 0,
6629 flatbuffers::Offset<armnnSerializer::ConstTensor> mean = 0,
6630 flatbuffers::Offset<armnnSerializer::ConstTensor> variance = 0,
6631 flatbuffers::Offset<armnnSerializer::ConstTensor> beta = 0,
6632 flatbuffers::Offset<armnnSerializer::ConstTensor> gamma = 0) {
6640 return builder_.
Finish();
6643 struct BatchNormalizationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6645 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6650 return GetField<float>(
VT_EPS, 0.0f);
6655 bool Verify(flatbuffers::Verifier &verifier)
const {
6656 return VerifyTableStart(verifier) &&
6657 VerifyField<float>(verifier,
VT_EPS) &&
6659 verifier.EndTable();
6664 typedef BatchNormalizationDescriptor
Table;
6665 flatbuffers::FlatBufferBuilder &
fbb_;
6675 start_ = fbb_.StartTable();
6678 flatbuffers::Offset<BatchNormalizationDescriptor>
Finish() {
6679 const auto end = fbb_.EndTable(start_);
6680 auto o = flatbuffers::Offset<BatchNormalizationDescriptor>(end);
6686 flatbuffers::FlatBufferBuilder &_fbb,
6692 return builder_.
Finish();
6696 struct ResizeBilinearLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6698 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6702 const armnnSerializer::LayerBase *
base()
const {
6703 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6705 const armnnSerializer::ResizeBilinearDescriptor *
descriptor()
const {
6706 return GetPointer<const armnnSerializer::ResizeBilinearDescriptor *>(
VT_DESCRIPTOR);
6708 bool Verify(flatbuffers::Verifier &verifier)
const {
6709 return VerifyTableStart(verifier) &&
6710 VerifyOffset(verifier,
VT_BASE) &&
6711 verifier.VerifyTable(base()) &&
6713 verifier.VerifyTable(descriptor()) &&
6714 verifier.EndTable();
6720 flatbuffers::FlatBufferBuilder &
fbb_;
6722 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6725 void add_descriptor(flatbuffers::Offset<armnnSerializer::ResizeBilinearDescriptor> descriptor) {
6730 start_ = fbb_.StartTable();
6733 flatbuffers::Offset<ResizeBilinearLayer>
Finish() {
6734 const auto end = fbb_.EndTable(start_);
6735 auto o = flatbuffers::Offset<ResizeBilinearLayer>(end);
6741 flatbuffers::FlatBufferBuilder &_fbb,
6742 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6743 flatbuffers::Offset<armnnSerializer::ResizeBilinearDescriptor> descriptor = 0) {
6747 return builder_.
Finish();
6750 struct ResizeBilinearDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6752 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6757 VT_HALFPIXELCENTERS = 12
6772 return GetField<uint8_t>(VT_HALFPIXELCENTERS, 0) != 0;
6774 bool Verify(flatbuffers::Verifier &verifier)
const {
6775 return VerifyTableStart(verifier) &&
6780 VerifyField<uint8_t>(verifier, VT_HALFPIXELCENTERS) &&
6781 verifier.EndTable();
6787 flatbuffers::FlatBufferBuilder &
fbb_;
6802 fbb_.AddElement<uint8_t>(ResizeBilinearDescriptor::VT_HALFPIXELCENTERS,
static_cast<uint8_t
>(halfPixelCenters), 0);
6806 start_ = fbb_.StartTable();
6809 flatbuffers::Offset<ResizeBilinearDescriptor>
Finish() {
6810 const auto end = fbb_.EndTable(start_);
6811 auto o = flatbuffers::Offset<ResizeBilinearDescriptor>(end);
6817 flatbuffers::FlatBufferBuilder &_fbb,
6818 uint32_t targetWidth = 0,
6819 uint32_t targetHeight = 0,
6821 bool alignCorners =
false,
6822 bool halfPixelCenters =
false) {
6829 return builder_.
Finish();
6832 struct SliceLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6834 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6838 const armnnSerializer::LayerBase *
base()
const {
6839 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6842 return GetPointer<const armnnSerializer::SliceDescriptor *>(
VT_DESCRIPTOR);
6844 bool Verify(flatbuffers::Verifier &verifier)
const {
6845 return VerifyTableStart(verifier) &&
6846 VerifyOffset(verifier,
VT_BASE) &&
6847 verifier.VerifyTable(base()) &&
6849 verifier.VerifyTable(descriptor()) &&
6850 verifier.EndTable();
6856 flatbuffers::FlatBufferBuilder &
fbb_;
6858 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6861 void add_descriptor(flatbuffers::Offset<armnnSerializer::SliceDescriptor> descriptor) {
6866 start_ = fbb_.StartTable();
6870 const auto end = fbb_.EndTable(start_);
6871 auto o = flatbuffers::Offset<SliceLayer>(end);
6877 flatbuffers::FlatBufferBuilder &_fbb,
6878 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6879 flatbuffers::Offset<armnnSerializer::SliceDescriptor> descriptor = 0) {
6883 return builder_.
Finish();
6886 struct SliceDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6888 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6892 const flatbuffers::Vector<uint32_t> *
begin()
const {
6893 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_BEGIN);
6895 const flatbuffers::Vector<uint32_t> *
size()
const {
6896 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_SIZE);
6898 bool Verify(flatbuffers::Verifier &verifier)
const {
6899 return VerifyTableStart(verifier) &&
6900 VerifyOffset(verifier,
VT_BEGIN) &&
6901 verifier.VerifyVector(begin()) &&
6902 VerifyOffset(verifier, VT_SIZE) &&
6903 verifier.VerifyVector(size()) &&
6904 verifier.EndTable();
6910 flatbuffers::FlatBufferBuilder &
fbb_;
6916 fbb_.AddOffset(SliceDescriptor::VT_SIZE, size);
6920 start_ = fbb_.StartTable();
6923 flatbuffers::Offset<SliceDescriptor>
Finish() {
6924 const auto end = fbb_.EndTable(start_);
6925 auto o = flatbuffers::Offset<SliceDescriptor>(end);
6931 flatbuffers::FlatBufferBuilder &_fbb,
6937 return builder_.
Finish();
6941 flatbuffers::FlatBufferBuilder &_fbb,
6942 const std::vector<uint32_t> *begin =
nullptr,
6943 const std::vector<uint32_t> *size =
nullptr) {
6944 auto begin__ = begin ? _fbb.CreateVector<uint32_t>(*begin) : 0;
6945 auto size__ = size ? _fbb.CreateVector<uint32_t>(*size) : 0;
6952 struct StridedSliceLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6954 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6958 const armnnSerializer::LayerBase *
base()
const {
6959 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6961 const armnnSerializer::StridedSliceDescriptor *
descriptor()
const {
6962 return GetPointer<const armnnSerializer::StridedSliceDescriptor *>(
VT_DESCRIPTOR);
6964 bool Verify(flatbuffers::Verifier &verifier)
const {
6965 return VerifyTableStart(verifier) &&
6966 VerifyOffset(verifier,
VT_BASE) &&
6967 verifier.VerifyTable(base()) &&
6969 verifier.VerifyTable(descriptor()) &&
6970 verifier.EndTable();
6976 flatbuffers::FlatBufferBuilder &
fbb_;
6978 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6981 void add_descriptor(flatbuffers::Offset<armnnSerializer::StridedSliceDescriptor> descriptor) {
6986 start_ = fbb_.StartTable();
6989 flatbuffers::Offset<StridedSliceLayer>
Finish() {
6990 const auto end = fbb_.EndTable(start_);
6991 auto o = flatbuffers::Offset<StridedSliceLayer>(end);
6997 flatbuffers::FlatBufferBuilder &_fbb,
6998 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6999 flatbuffers::Offset<armnnSerializer::StridedSliceDescriptor> descriptor = 0) {
7003 return builder_.
Finish();
7006 struct StridedSliceDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7008 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7019 const flatbuffers::Vector<int32_t> *
begin()
const {
7020 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_BEGIN);
7022 const flatbuffers::Vector<int32_t> *
end()
const {
7023 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_END);
7025 const flatbuffers::Vector<int32_t> *
stride()
const {
7026 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_STRIDE);
7046 bool Verify(flatbuffers::Verifier &verifier)
const {
7047 return VerifyTableStart(verifier) &&
7048 VerifyOffset(verifier,
VT_BEGIN) &&
7049 verifier.VerifyVector(begin()) &&
7050 VerifyOffset(verifier,
VT_END) &&
7051 verifier.VerifyVector(end()) &&
7053 verifier.VerifyVector(stride()) &&
7055 VerifyField<int32_t>(verifier,
VT_ENDMASK) &&
7060 verifier.EndTable();
7066 flatbuffers::FlatBufferBuilder &
fbb_;
7097 start_ = fbb_.StartTable();
7100 flatbuffers::Offset<StridedSliceDescriptor>
Finish() {
7101 const auto end = fbb_.EndTable(start_);
7102 auto o = flatbuffers::Offset<StridedSliceDescriptor>(end);
7108 flatbuffers::FlatBufferBuilder &_fbb,
7112 int32_t beginMask = 0,
7113 int32_t endMask = 0,
7114 int32_t shrinkAxisMask = 0,
7115 int32_t ellipsisMask = 0,
7116 int32_t newAxisMask = 0,
7128 return builder_.
Finish();
7132 flatbuffers::FlatBufferBuilder &_fbb,
7133 const std::vector<int32_t> *begin =
nullptr,
7134 const std::vector<int32_t> *end =
nullptr,
7135 const std::vector<int32_t> *stride =
nullptr,
7136 int32_t beginMask = 0,
7137 int32_t endMask = 0,
7138 int32_t shrinkAxisMask = 0,
7139 int32_t ellipsisMask = 0,
7140 int32_t newAxisMask = 0,
7142 auto begin__ = begin ? _fbb.CreateVector<int32_t>(*begin) : 0;
7143 auto end__ = end ? _fbb.CreateVector<int32_t>(*end) : 0;
7144 auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0;
7158 struct ConcatLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7160 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7164 const armnnSerializer::LayerBase *
base()
const {
7165 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
7168 return GetPointer<const armnnSerializer::OriginsDescriptor *>(
VT_DESCRIPTOR);
7170 bool Verify(flatbuffers::Verifier &verifier)
const {
7171 return VerifyTableStart(verifier) &&
7172 VerifyOffset(verifier,
VT_BASE) &&
7173 verifier.VerifyTable(base()) &&
7175 verifier.VerifyTable(descriptor()) &&
7176 verifier.EndTable();
7182 flatbuffers::FlatBufferBuilder &
fbb_;
7184 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
7187 void add_descriptor(flatbuffers::Offset<armnnSerializer::OriginsDescriptor> descriptor) {
7192 start_ = fbb_.StartTable();
7196 const auto end = fbb_.EndTable(start_);
7197 auto o = flatbuffers::Offset<ConcatLayer>(end);
7203 flatbuffers::FlatBufferBuilder &_fbb,
7204 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7205 flatbuffers::Offset<armnnSerializer::OriginsDescriptor> descriptor = 0) {
7209 return builder_.
Finish();
7213 struct MergerLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7215 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7219 const armnnSerializer::LayerBase *
base()
const {
7220 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
7223 return GetPointer<const armnnSerializer::OriginsDescriptor *>(
VT_DESCRIPTOR);
7225 bool Verify(flatbuffers::Verifier &verifier)
const {
7226 return VerifyTableStart(verifier) &&
7227 VerifyOffset(verifier,
VT_BASE) &&
7228 verifier.VerifyTable(base()) &&
7230 verifier.VerifyTable(descriptor()) &&
7231 verifier.EndTable();
7237 flatbuffers::FlatBufferBuilder &
fbb_;
7239 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
7242 void add_descriptor(flatbuffers::Offset<armnnSerializer::OriginsDescriptor> descriptor) {
7247 start_ = fbb_.StartTable();
7251 const auto end = fbb_.EndTable(start_);
7252 auto o = flatbuffers::Offset<MergerLayer>(end);
7258 flatbuffers::FlatBufferBuilder &_fbb,
7259 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7260 flatbuffers::Offset<armnnSerializer::OriginsDescriptor> descriptor = 0) {
7264 return builder_.
Finish();
7267 struct UintVector FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7269 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7272 const flatbuffers::Vector<uint32_t> *
data()
const {
7273 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DATA);
7275 bool Verify(flatbuffers::Verifier &verifier)
const {
7276 return VerifyTableStart(verifier) &&
7277 VerifyOffset(verifier, VT_DATA) &&
7278 verifier.VerifyVector(data()) &&
7279 verifier.EndTable();
7285 flatbuffers::FlatBufferBuilder &
fbb_;
7288 fbb_.AddOffset(UintVector::VT_DATA, data);
7292 start_ = fbb_.StartTable();
7296 const auto end = fbb_.EndTable(start_);
7297 auto o = flatbuffers::Offset<UintVector>(end);
7303 flatbuffers::FlatBufferBuilder &_fbb,
7307 return builder_.
Finish();
7311 flatbuffers::FlatBufferBuilder &_fbb,
7312 const std::vector<uint32_t> *data =
nullptr) {
7313 auto data__ = data ? _fbb.CreateVector<uint32_t>(*data) : 0;
7319 struct OriginsDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7321 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7336 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>> *
viewOrigins()
const {
7337 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>> *>(VT_VIEWORIGINS);
7339 bool Verify(flatbuffers::Verifier &verifier)
const {
7340 return VerifyTableStart(verifier) &&
7344 VerifyOffset(verifier, VT_VIEWORIGINS) &&
7345 verifier.VerifyVector(viewOrigins()) &&
7346 verifier.VerifyVectorOfTables(viewOrigins()) &&
7347 verifier.EndTable();
7353 flatbuffers::FlatBufferBuilder &
fbb_;
7365 fbb_.AddOffset(OriginsDescriptor::VT_VIEWORIGINS, viewOrigins);
7369 start_ = fbb_.StartTable();
7372 flatbuffers::Offset<OriginsDescriptor>
Finish() {
7373 const auto end = fbb_.EndTable(start_);
7374 auto o = flatbuffers::Offset<OriginsDescriptor>(end);
7380 flatbuffers::FlatBufferBuilder &_fbb,
7381 uint32_t concatAxis = 0,
7382 uint32_t numViews = 0,
7383 uint32_t numDimensions = 0,
7384 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>>> viewOrigins = 0) {
7390 return builder_.
Finish();
7394 flatbuffers::FlatBufferBuilder &_fbb,
7395 uint32_t concatAxis = 0,
7396 uint32_t numViews = 0,
7397 uint32_t numDimensions = 0,
7398 const std::vector<flatbuffers::Offset<armnnSerializer::UintVector>> *viewOrigins =
nullptr) {
7399 auto viewOrigins__ = viewOrigins ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::UintVector>>(*viewOrigins) : 0;
7408 struct ViewsDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7410 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7414 const armnnSerializer::OriginsDescriptor *
origins()
const {
7415 return GetPointer<const armnnSerializer::OriginsDescriptor *>(
VT_ORIGINS);
7417 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>> *
viewSizes()
const {
7418 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>> *>(VT_VIEWSIZES);
7420 bool Verify(flatbuffers::Verifier &verifier)
const {
7421 return VerifyTableStart(verifier) &&
7423 verifier.VerifyTable(origins()) &&
7424 VerifyOffset(verifier, VT_VIEWSIZES) &&
7425 verifier.VerifyVector(viewSizes()) &&
7426 verifier.VerifyVectorOfTables(viewSizes()) &&
7427 verifier.EndTable();
7433 flatbuffers::FlatBufferBuilder &
fbb_;
7435 void add_origins(flatbuffers::Offset<armnnSerializer::OriginsDescriptor> origins) {
7439 fbb_.AddOffset(ViewsDescriptor::VT_VIEWSIZES, viewSizes);
7443 start_ = fbb_.StartTable();
7446 flatbuffers::Offset<ViewsDescriptor>
Finish() {
7447 const auto end = fbb_.EndTable(start_);
7448 auto o = flatbuffers::Offset<ViewsDescriptor>(end);
7454 flatbuffers::FlatBufferBuilder &_fbb,
7455 flatbuffers::Offset<armnnSerializer::OriginsDescriptor> origins = 0,
7456 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>>> viewSizes = 0) {
7460 return builder_.
Finish();
7464 flatbuffers::FlatBufferBuilder &_fbb,
7465 flatbuffers::Offset<armnnSerializer::OriginsDescriptor> origins = 0,
7466 const std::vector<flatbuffers::Offset<armnnSerializer::UintVector>> *viewSizes =
nullptr) {
7467 auto viewSizes__ = viewSizes ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::UintVector>>(*viewSizes) : 0;
7474 struct SplitterLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7476 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7480 const armnnSerializer::LayerBase *
base()
const {
7481 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
7484 return GetPointer<const armnnSerializer::ViewsDescriptor *>(
VT_DESCRIPTOR);
7486 bool Verify(flatbuffers::Verifier &verifier)
const {
7487 return VerifyTableStart(verifier) &&
7488 VerifyOffset(verifier,
VT_BASE) &&
7489 verifier.VerifyTable(base()) &&
7491 verifier.VerifyTable(descriptor()) &&
7492 verifier.EndTable();
7498 flatbuffers::FlatBufferBuilder &
fbb_;
7500 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
7503 void add_descriptor(flatbuffers::Offset<armnnSerializer::ViewsDescriptor> descriptor) {
7508 start_ = fbb_.StartTable();
7511 flatbuffers::Offset<SplitterLayer>
Finish() {
7512 const auto end = fbb_.EndTable(start_);
7513 auto o = flatbuffers::Offset<SplitterLayer>(end);
7519 flatbuffers::FlatBufferBuilder &_fbb,
7520 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7521 flatbuffers::Offset<armnnSerializer::ViewsDescriptor> descriptor = 0) {
7525 return builder_.
Finish();
7528 struct DetectionPostProcessLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7530 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7535 const armnnSerializer::LayerBase *
base()
const {
7536 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
7538 const armnnSerializer::DetectionPostProcessDescriptor *
descriptor()
const {
7539 return GetPointer<const armnnSerializer::DetectionPostProcessDescriptor *>(
VT_DESCRIPTOR);
7541 const armnnSerializer::ConstTensor *
anchors()
const {
7542 return GetPointer<const armnnSerializer::ConstTensor *>(VT_ANCHORS);
7544 bool Verify(flatbuffers::Verifier &verifier)
const {
7545 return VerifyTableStart(verifier) &&
7546 VerifyOffset(verifier,
VT_BASE) &&
7547 verifier.VerifyTable(base()) &&
7549 verifier.VerifyTable(descriptor()) &&
7550 VerifyOffset(verifier, VT_ANCHORS) &&
7551 verifier.VerifyTable(anchors()) &&
7552 verifier.EndTable();
7557 typedef DetectionPostProcessLayer
Table;
7558 flatbuffers::FlatBufferBuilder &
fbb_;
7560 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
7563 void add_descriptor(flatbuffers::Offset<armnnSerializer::DetectionPostProcessDescriptor> descriptor) {
7566 void add_anchors(flatbuffers::Offset<armnnSerializer::ConstTensor> anchors) {
7567 fbb_.AddOffset(DetectionPostProcessLayer::VT_ANCHORS, anchors);
7571 start_ = fbb_.StartTable();
7574 flatbuffers::Offset<DetectionPostProcessLayer>
Finish() {
7575 const auto end = fbb_.EndTable(start_);
7576 auto o = flatbuffers::Offset<DetectionPostProcessLayer>(end);
7582 flatbuffers::FlatBufferBuilder &_fbb,
7583 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7584 flatbuffers::Offset<armnnSerializer::DetectionPostProcessDescriptor> descriptor = 0,
7585 flatbuffers::Offset<armnnSerializer::ConstTensor> anchors = 0) {
7590 return builder_.
Finish();
7593 struct DetectionPostProcessDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7595 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7630 return GetField<float>(
VT_SCALEX, 0.0f);
7633 return GetField<float>(
VT_SCALEY, 0.0f);
7636 return GetField<float>(
VT_SCALEW, 0.0f);
7639 return GetField<float>(VT_SCALEH, 0.0f);
7641 bool Verify(flatbuffers::Verifier &verifier)
const {
7642 return VerifyTableStart(verifier) &&
7650 VerifyField<float>(verifier,
VT_SCALEX) &&
7651 VerifyField<float>(verifier,
VT_SCALEY) &&
7652 VerifyField<float>(verifier,
VT_SCALEW) &&
7653 VerifyField<float>(verifier, VT_SCALEH) &&
7654 verifier.EndTable();
7659 typedef DetectionPostProcessDescriptor
Table;
7660 flatbuffers::FlatBufferBuilder &
fbb_;
7693 fbb_.AddElement<
float>(DetectionPostProcessDescriptor::VT_SCALEH, scaleH, 0.0f);
7697 start_ = fbb_.StartTable();
7700 flatbuffers::Offset<DetectionPostProcessDescriptor>
Finish() {
7701 const auto end = fbb_.EndTable(start_);
7702 auto o = flatbuffers::Offset<DetectionPostProcessDescriptor>(end);
7708 flatbuffers::FlatBufferBuilder &_fbb,
7709 uint32_t maxDetections = 0,
7710 uint32_t maxClassesPerDetection = 0,
7711 uint32_t detectionsPerClass = 0,
7712 float nmsScoreThreshold = 0.0f,
7713 float nmsIouThreshold = 0.0f,
7714 uint32_t numClasses = 0,
7715 bool useRegularNms =
false,
7716 float scaleX = 0.0f,
7717 float scaleY = 0.0f,
7718 float scaleW = 0.0f,
7719 float scaleH = 0.0f) {
7732 return builder_.
Finish();
7735 struct LstmInputParams FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7737 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7758 VT_OUTPUTLAYERNORMWEIGHTS = 44
7782 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_CELLBIAS);
7821 return GetPointer<const armnnSerializer::ConstTensor *>(VT_OUTPUTLAYERNORMWEIGHTS);
7823 bool Verify(flatbuffers::Verifier &verifier)
const {
7824 return VerifyTableStart(verifier) &&
7826 verifier.VerifyTable(inputToForgetWeights()) &&
7828 verifier.VerifyTable(inputToCellWeights()) &&
7830 verifier.VerifyTable(inputToOutputWeights()) &&
7832 verifier.VerifyTable(recurrentToForgetWeights()) &&
7834 verifier.VerifyTable(recurrentToCellWeights()) &&
7836 verifier.VerifyTable(recurrentToOutputWeights()) &&
7838 verifier.VerifyTable(forgetGateBias()) &&
7840 verifier.VerifyTable(cellBias()) &&
7842 verifier.VerifyTable(outputGateBias()) &&
7844 verifier.VerifyTable(inputToInputWeights()) &&
7846 verifier.VerifyTable(recurrentToInputWeights()) &&
7848 verifier.VerifyTable(cellToInputWeights()) &&
7850 verifier.VerifyTable(inputGateBias()) &&
7852 verifier.VerifyTable(projectionWeights()) &&
7854 verifier.VerifyTable(projectionBias()) &&
7856 verifier.VerifyTable(cellToForgetWeights()) &&
7858 verifier.VerifyTable(cellToOutputWeights()) &&
7860 verifier.VerifyTable(inputLayerNormWeights()) &&
7862 verifier.VerifyTable(forgetLayerNormWeights()) &&
7864 verifier.VerifyTable(cellLayerNormWeights()) &&
7865 VerifyOffset(verifier, VT_OUTPUTLAYERNORMWEIGHTS) &&
7866 verifier.VerifyTable(outputLayerNormWeights()) &&
7867 verifier.EndTable();
7873 flatbuffers::FlatBufferBuilder &
fbb_;
7896 void add_cellBias(flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias) {
7936 fbb_.AddOffset(LstmInputParams::VT_OUTPUTLAYERNORMWEIGHTS, outputLayerNormWeights);
7940 start_ = fbb_.StartTable();
7943 flatbuffers::Offset<LstmInputParams>
Finish() {
7944 const auto end = fbb_.EndTable(start_);
7945 auto o = flatbuffers::Offset<LstmInputParams>(end);
7951 flatbuffers::FlatBufferBuilder &_fbb,
7952 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToForgetWeights = 0,
7953 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToCellWeights = 0,
7954 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToOutputWeights = 0,
7955 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToForgetWeights = 0,
7956 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToCellWeights = 0,
7957 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToOutputWeights = 0,
7958 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetGateBias = 0,
7959 flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias = 0,
7960 flatbuffers::Offset<armnnSerializer::ConstTensor> outputGateBias = 0,
7961 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToInputWeights = 0,
7962 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToInputWeights = 0,
7963 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToInputWeights = 0,
7964 flatbuffers::Offset<armnnSerializer::ConstTensor> inputGateBias = 0,
7965 flatbuffers::Offset<armnnSerializer::ConstTensor> projectionWeights = 0,
7966 flatbuffers::Offset<armnnSerializer::ConstTensor> projectionBias = 0,
7967 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToForgetWeights = 0,
7968 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToOutputWeights = 0,
7969 flatbuffers::Offset<armnnSerializer::ConstTensor> inputLayerNormWeights = 0,
7970 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetLayerNormWeights = 0,
7971 flatbuffers::Offset<armnnSerializer::ConstTensor> cellLayerNormWeights = 0,
7972 flatbuffers::Offset<armnnSerializer::ConstTensor> outputLayerNormWeights = 0) {
7995 return builder_.
Finish();
7998 struct LstmDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8000 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8030 bool Verify(flatbuffers::Verifier &verifier)
const {
8031 return VerifyTableStart(verifier) &&
8039 verifier.EndTable();
8045 flatbuffers::FlatBufferBuilder &
fbb_;
8070 start_ = fbb_.StartTable();
8073 flatbuffers::Offset<LstmDescriptor>
Finish() {
8074 const auto end = fbb_.EndTable(start_);
8075 auto o = flatbuffers::Offset<LstmDescriptor>(end);
8081 flatbuffers::FlatBufferBuilder &_fbb,
8082 uint32_t activationFunc = 0,
8083 float clippingThresCell = 0.0f,
8084 float clippingThresProj = 0.0f,
8085 bool cifgEnabled =
true,
8086 bool peepholeEnabled =
false,
8087 bool projectionEnabled =
false,
8088 bool layerNormEnabled =
false) {
8097 return builder_.
Finish();
8100 struct LstmLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8102 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8107 const armnnSerializer::LayerBase *
base()
const {
8108 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8111 return GetPointer<const armnnSerializer::LstmDescriptor *>(
VT_DESCRIPTOR);
8114 return GetPointer<const armnnSerializer::LstmInputParams *>(VT_INPUTPARAMS);
8116 bool Verify(flatbuffers::Verifier &verifier)
const {
8117 return VerifyTableStart(verifier) &&
8118 VerifyOffset(verifier,
VT_BASE) &&
8119 verifier.VerifyTable(base()) &&
8121 verifier.VerifyTable(descriptor()) &&
8122 VerifyOffset(verifier, VT_INPUTPARAMS) &&
8123 verifier.VerifyTable(inputParams()) &&
8124 verifier.EndTable();
8130 flatbuffers::FlatBufferBuilder &
fbb_;
8132 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8135 void add_descriptor(flatbuffers::Offset<armnnSerializer::LstmDescriptor> descriptor) {
8139 fbb_.AddOffset(LstmLayer::VT_INPUTPARAMS, inputParams);
8143 start_ = fbb_.StartTable();
8147 const auto end = fbb_.EndTable(start_);
8148 auto o = flatbuffers::Offset<LstmLayer>(end);
8154 flatbuffers::FlatBufferBuilder &_fbb,
8155 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
8156 flatbuffers::Offset<armnnSerializer::LstmDescriptor> descriptor = 0,
8157 flatbuffers::Offset<armnnSerializer::LstmInputParams> inputParams = 0) {
8162 return builder_.
Finish();
8165 struct QLstmInputParams FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8167 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8188 VT_OUTPUTLAYERNORMWEIGHTS = 44
8212 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_CELLBIAS);
8251 return GetPointer<const armnnSerializer::ConstTensor *>(VT_OUTPUTLAYERNORMWEIGHTS);
8253 bool Verify(flatbuffers::Verifier &verifier)
const {
8254 return VerifyTableStart(verifier) &&
8256 verifier.VerifyTable(inputToForgetWeights()) &&
8258 verifier.VerifyTable(inputToCellWeights()) &&
8260 verifier.VerifyTable(inputToOutputWeights()) &&
8262 verifier.VerifyTable(recurrentToForgetWeights()) &&
8264 verifier.VerifyTable(recurrentToCellWeights()) &&
8266 verifier.VerifyTable(recurrentToOutputWeights()) &&
8268 verifier.VerifyTable(forgetGateBias()) &&
8270 verifier.VerifyTable(cellBias()) &&
8272 verifier.VerifyTable(outputGateBias()) &&
8274 verifier.VerifyTable(inputToInputWeights()) &&
8276 verifier.VerifyTable(recurrentToInputWeights()) &&
8278 verifier.VerifyTable(inputGateBias()) &&
8280 verifier.VerifyTable(projectionWeights()) &&
8282 verifier.VerifyTable(projectionBias()) &&
8284 verifier.VerifyTable(cellToInputWeights()) &&
8286 verifier.VerifyTable(cellToForgetWeights()) &&
8288 verifier.VerifyTable(cellToOutputWeights()) &&
8290 verifier.VerifyTable(inputLayerNormWeights()) &&
8292 verifier.VerifyTable(forgetLayerNormWeights()) &&
8294 verifier.VerifyTable(cellLayerNormWeights()) &&
8295 VerifyOffset(verifier, VT_OUTPUTLAYERNORMWEIGHTS) &&
8296 verifier.VerifyTable(outputLayerNormWeights()) &&
8297 verifier.EndTable();
8303 flatbuffers::FlatBufferBuilder &
fbb_;
8326 void add_cellBias(flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias) {
8366 fbb_.AddOffset(QLstmInputParams::VT_OUTPUTLAYERNORMWEIGHTS, outputLayerNormWeights);
8370 start_ = fbb_.StartTable();
8373 flatbuffers::Offset<QLstmInputParams>
Finish() {
8374 const auto end = fbb_.EndTable(start_);
8375 auto o = flatbuffers::Offset<QLstmInputParams>(end);
8381 flatbuffers::FlatBufferBuilder &_fbb,
8382 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToForgetWeights = 0,
8383 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToCellWeights = 0,
8384 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToOutputWeights = 0,
8385 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToForgetWeights = 0,
8386 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToCellWeights = 0,
8387 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToOutputWeights = 0,
8388 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetGateBias = 0,
8389 flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias = 0,
8390 flatbuffers::Offset<armnnSerializer::ConstTensor> outputGateBias = 0,
8391 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToInputWeights = 0,
8392 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToInputWeights = 0,
8393 flatbuffers::Offset<armnnSerializer::ConstTensor> inputGateBias = 0,
8394 flatbuffers::Offset<armnnSerializer::ConstTensor> projectionWeights = 0,
8395 flatbuffers::Offset<armnnSerializer::ConstTensor> projectionBias = 0,
8396 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToInputWeights = 0,
8397 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToForgetWeights = 0,
8398 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToOutputWeights = 0,
8399 flatbuffers::Offset<armnnSerializer::ConstTensor> inputLayerNormWeights = 0,
8400 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetLayerNormWeights = 0,
8401 flatbuffers::Offset<armnnSerializer::ConstTensor> cellLayerNormWeights = 0,
8402 flatbuffers::Offset<armnnSerializer::ConstTensor> outputLayerNormWeights = 0) {
8425 return builder_.
Finish();
8428 struct QLstmDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8430 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8442 VT_HIDDENSTATESCALE = 26
8478 return GetField<float>(VT_HIDDENSTATESCALE, 0.0f);
8480 bool Verify(flatbuffers::Verifier &verifier)
const {
8481 return VerifyTableStart(verifier) &&
8493 VerifyField<float>(verifier, VT_HIDDENSTATESCALE) &&
8494 verifier.EndTable();
8500 flatbuffers::FlatBufferBuilder &
fbb_;
8536 fbb_.AddElement<
float>(QLstmDescriptor::VT_HIDDENSTATESCALE, hiddenStateScale, 0.0f);
8540 start_ = fbb_.StartTable();
8543 flatbuffers::Offset<QLstmDescriptor>
Finish() {
8544 const auto end = fbb_.EndTable(start_);
8545 auto o = flatbuffers::Offset<QLstmDescriptor>(end);
8551 flatbuffers::FlatBufferBuilder &_fbb,
8552 bool cifgEnabled =
true,
8553 bool peepholeEnabled =
false,
8554 bool projectionEnabled =
false,
8555 bool layerNormEnabled =
false,
8556 float cellClip = 0.0f,
8557 float projectionClip = 0.0f,
8558 float inputIntermediateScale = 0.0f,
8559 float forgetIntermediateScale = 0.0f,
8560 float cellIntermediateScale = 0.0f,
8561 float outputIntermediateScale = 0.0f,
8562 int32_t hiddenStateZeroPoint = 0,
8563 float hiddenStateScale = 0.0f) {
8577 return builder_.
Finish();
8580 struct QLstmLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8582 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8587 const armnnSerializer::LayerBase *
base()
const {
8588 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8591 return GetPointer<const armnnSerializer::QLstmDescriptor *>(
VT_DESCRIPTOR);
8594 return GetPointer<const armnnSerializer::QLstmInputParams *>(VT_INPUTPARAMS);
8596 bool Verify(flatbuffers::Verifier &verifier)
const {
8597 return VerifyTableStart(verifier) &&
8598 VerifyOffset(verifier,
VT_BASE) &&
8599 verifier.VerifyTable(base()) &&
8601 verifier.VerifyTable(descriptor()) &&
8602 VerifyOffset(verifier, VT_INPUTPARAMS) &&
8603 verifier.VerifyTable(inputParams()) &&
8604 verifier.EndTable();
8610 flatbuffers::FlatBufferBuilder &
fbb_;
8612 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8615 void add_descriptor(flatbuffers::Offset<armnnSerializer::QLstmDescriptor> descriptor) {
8618 void add_inputParams(flatbuffers::Offset<armnnSerializer::QLstmInputParams> inputParams) {
8619 fbb_.AddOffset(QLstmLayer::VT_INPUTPARAMS, inputParams);
8623 start_ = fbb_.StartTable();
8627 const auto end = fbb_.EndTable(start_);
8628 auto o = flatbuffers::Offset<QLstmLayer>(end);
8634 flatbuffers::FlatBufferBuilder &_fbb,
8635 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
8636 flatbuffers::Offset<armnnSerializer::QLstmDescriptor> descriptor = 0,
8637 flatbuffers::Offset<armnnSerializer::QLstmInputParams> inputParams = 0) {
8642 return builder_.
Finish();
8645 struct QuantizedLstmInputParams FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8647 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8692 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_CELLBIAS);
8697 bool Verify(flatbuffers::Verifier &verifier)
const {
8698 return VerifyTableStart(verifier) &&
8700 verifier.VerifyTable(inputToInputWeights()) &&
8702 verifier.VerifyTable(inputToForgetWeights()) &&
8704 verifier.VerifyTable(inputToCellWeights()) &&
8706 verifier.VerifyTable(inputToOutputWeights()) &&
8708 verifier.VerifyTable(recurrentToInputWeights()) &&
8710 verifier.VerifyTable(recurrentToForgetWeights()) &&
8712 verifier.VerifyTable(recurrentToCellWeights()) &&
8714 verifier.VerifyTable(recurrentToOutputWeights()) &&
8716 verifier.VerifyTable(inputGateBias()) &&
8718 verifier.VerifyTable(forgetGateBias()) &&
8720 verifier.VerifyTable(cellBias()) &&
8722 verifier.VerifyTable(outputGateBias()) &&
8723 verifier.EndTable();
8729 flatbuffers::FlatBufferBuilder &
fbb_;
8761 void add_cellBias(flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias) {
8769 start_ = fbb_.StartTable();
8772 flatbuffers::Offset<QuantizedLstmInputParams>
Finish() {
8773 const auto end = fbb_.EndTable(start_);
8774 auto o = flatbuffers::Offset<QuantizedLstmInputParams>(end);
8780 flatbuffers::FlatBufferBuilder &_fbb,
8781 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToInputWeights = 0,
8782 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToForgetWeights = 0,
8783 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToCellWeights = 0,
8784 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToOutputWeights = 0,
8785 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToInputWeights = 0,
8786 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToForgetWeights = 0,
8787 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToCellWeights = 0,
8788 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToOutputWeights = 0,
8789 flatbuffers::Offset<armnnSerializer::ConstTensor> inputGateBias = 0,
8790 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetGateBias = 0,
8791 flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias = 0,
8792 flatbuffers::Offset<armnnSerializer::ConstTensor> outputGateBias = 0) {
8806 return builder_.
Finish();
8809 struct QuantizedLstmLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8811 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8815 const armnnSerializer::LayerBase *
base()
const {
8816 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8818 const armnnSerializer::QuantizedLstmInputParams *
inputParams()
const {
8819 return GetPointer<const armnnSerializer::QuantizedLstmInputParams *>(VT_INPUTPARAMS);
8821 bool Verify(flatbuffers::Verifier &verifier)
const {
8822 return VerifyTableStart(verifier) &&
8823 VerifyOffset(verifier,
VT_BASE) &&
8824 verifier.VerifyTable(base()) &&
8825 VerifyOffset(verifier, VT_INPUTPARAMS) &&
8826 verifier.VerifyTable(inputParams()) &&
8827 verifier.EndTable();
8833 flatbuffers::FlatBufferBuilder &
fbb_;
8835 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8838 void add_inputParams(flatbuffers::Offset<armnnSerializer::QuantizedLstmInputParams> inputParams) {
8839 fbb_.AddOffset(QuantizedLstmLayer::VT_INPUTPARAMS, inputParams);
8843 start_ = fbb_.StartTable();
8846 flatbuffers::Offset<QuantizedLstmLayer>
Finish() {
8847 const auto end = fbb_.EndTable(start_);
8848 auto o = flatbuffers::Offset<QuantizedLstmLayer>(end);
8854 flatbuffers::FlatBufferBuilder &_fbb,
8855 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
8856 flatbuffers::Offset<armnnSerializer::QuantizedLstmInputParams> inputParams = 0) {
8860 return builder_.
Finish();
8863 struct DequantizeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8865 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8868 const armnnSerializer::LayerBase *
base()
const {
8869 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8871 bool Verify(flatbuffers::Verifier &verifier)
const {
8872 return VerifyTableStart(verifier) &&
8873 VerifyOffset(verifier,
VT_BASE) &&
8874 verifier.VerifyTable(base()) &&
8875 verifier.EndTable();
8881 flatbuffers::FlatBufferBuilder &
fbb_;
8883 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8888 start_ = fbb_.StartTable();
8891 flatbuffers::Offset<DequantizeLayer>
Finish() {
8892 const auto end = fbb_.EndTable(start_);
8893 auto o = flatbuffers::Offset<DequantizeLayer>(end);
8899 flatbuffers::FlatBufferBuilder &_fbb,
8900 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
8903 return builder_.
Finish();
8906 struct MergeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8908 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8911 const armnnSerializer::LayerBase *
base()
const {
8912 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8914 bool Verify(flatbuffers::Verifier &verifier)
const {
8915 return VerifyTableStart(verifier) &&
8916 VerifyOffset(verifier,
VT_BASE) &&
8917 verifier.VerifyTable(base()) &&
8918 verifier.EndTable();
8924 flatbuffers::FlatBufferBuilder &
fbb_;
8926 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8931 start_ = fbb_.StartTable();
8935 const auto end = fbb_.EndTable(start_);
8936 auto o = flatbuffers::Offset<MergeLayer>(end);
8942 flatbuffers::FlatBufferBuilder &_fbb,
8943 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
8946 return builder_.
Finish();
8949 struct SwitchLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8951 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8954 const armnnSerializer::LayerBase *
base()
const {
8955 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8957 bool Verify(flatbuffers::Verifier &verifier)
const {
8958 return VerifyTableStart(verifier) &&
8959 VerifyOffset(verifier,
VT_BASE) &&
8960 verifier.VerifyTable(base()) &&
8961 verifier.EndTable();
8967 flatbuffers::FlatBufferBuilder &
fbb_;
8969 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8974 start_ = fbb_.StartTable();
8978 const auto end = fbb_.EndTable(start_);
8979 auto o = flatbuffers::Offset<SwitchLayer>(end);
8985 flatbuffers::FlatBufferBuilder &_fbb,
8986 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
8989 return builder_.
Finish();
8992 struct PreluLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8994 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8997 const armnnSerializer::LayerBase *
base()
const {
8998 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9000 bool Verify(flatbuffers::Verifier &verifier)
const {
9001 return VerifyTableStart(verifier) &&
9002 VerifyOffset(verifier,
VT_BASE) &&
9003 verifier.VerifyTable(base()) &&
9004 verifier.EndTable();
9010 flatbuffers::FlatBufferBuilder &
fbb_;
9012 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9017 start_ = fbb_.StartTable();
9021 const auto end = fbb_.EndTable(start_);
9022 auto o = flatbuffers::Offset<PreluLayer>(end);
9028 flatbuffers::FlatBufferBuilder &_fbb,
9029 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
9032 return builder_.
Finish();
9035 struct TransposeConvolution2dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9037 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9043 const armnnSerializer::LayerBase *
base()
const {
9044 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9046 const armnnSerializer::TransposeConvolution2dDescriptor *
descriptor()
const {
9047 return GetPointer<const armnnSerializer::TransposeConvolution2dDescriptor *>(
VT_DESCRIPTOR);
9049 const armnnSerializer::ConstTensor *
weights()
const {
9050 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_WEIGHTS);
9052 const armnnSerializer::ConstTensor *
biases()
const {
9053 return GetPointer<const armnnSerializer::ConstTensor *>(VT_BIASES);
9055 bool Verify(flatbuffers::Verifier &verifier)
const {
9056 return VerifyTableStart(verifier) &&
9057 VerifyOffset(verifier,
VT_BASE) &&
9058 verifier.VerifyTable(base()) &&
9060 verifier.VerifyTable(descriptor()) &&
9062 verifier.VerifyTable(weights()) &&
9063 VerifyOffset(verifier, VT_BIASES) &&
9064 verifier.VerifyTable(biases()) &&
9065 verifier.EndTable();
9070 typedef TransposeConvolution2dLayer
Table;
9071 flatbuffers::FlatBufferBuilder &
fbb_;
9073 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9076 void add_descriptor(flatbuffers::Offset<armnnSerializer::TransposeConvolution2dDescriptor> descriptor) {
9079 void add_weights(flatbuffers::Offset<armnnSerializer::ConstTensor> weights) {
9082 void add_biases(flatbuffers::Offset<armnnSerializer::ConstTensor> biases) {
9083 fbb_.AddOffset(TransposeConvolution2dLayer::VT_BIASES, biases);
9087 start_ = fbb_.StartTable();
9090 flatbuffers::Offset<TransposeConvolution2dLayer>
Finish() {
9091 const auto end = fbb_.EndTable(start_);
9092 auto o = flatbuffers::Offset<TransposeConvolution2dLayer>(end);
9098 flatbuffers::FlatBufferBuilder &_fbb,
9099 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9100 flatbuffers::Offset<armnnSerializer::TransposeConvolution2dDescriptor> descriptor = 0,
9101 flatbuffers::Offset<armnnSerializer::ConstTensor> weights = 0,
9102 flatbuffers::Offset<armnnSerializer::ConstTensor> biases = 0) {
9108 return builder_.
Finish();
9111 struct TransposeConvolution2dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9113 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9130 return GetField<uint32_t>(
VT_PADTOP, 0);
9147 bool Verify(flatbuffers::Verifier &verifier)
const {
9148 return VerifyTableStart(verifier) &&
9149 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
9151 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
9153 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
9154 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
9157 verifier.EndTable();
9162 typedef TransposeConvolution2dDescriptor
Table;
9163 flatbuffers::FlatBufferBuilder &
fbb_;
9191 start_ = fbb_.StartTable();
9194 flatbuffers::Offset<TransposeConvolution2dDescriptor>
Finish() {
9195 const auto end = fbb_.EndTable(start_);
9196 auto o = flatbuffers::Offset<TransposeConvolution2dDescriptor>(end);
9202 flatbuffers::FlatBufferBuilder &_fbb,
9203 uint32_t padLeft = 0,
9204 uint32_t padRight = 0,
9205 uint32_t padTop = 0,
9206 uint32_t padBottom = 0,
9207 uint32_t strideX = 0,
9208 uint32_t strideY = 0,
9209 bool biasEnabled =
false,
9220 return builder_.
Finish();
9223 struct TransposeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9225 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9229 const armnnSerializer::LayerBase *
base()
const {
9230 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9233 return GetPointer<const armnnSerializer::TransposeDescriptor *>(
VT_DESCRIPTOR);
9235 bool Verify(flatbuffers::Verifier &verifier)
const {
9236 return VerifyTableStart(verifier) &&
9237 VerifyOffset(verifier,
VT_BASE) &&
9238 verifier.VerifyTable(base()) &&
9240 verifier.VerifyTable(descriptor()) &&
9241 verifier.EndTable();
9247 flatbuffers::FlatBufferBuilder &
fbb_;
9249 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9252 void add_descriptor(flatbuffers::Offset<armnnSerializer::TransposeDescriptor> descriptor) {
9257 start_ = fbb_.StartTable();
9260 flatbuffers::Offset<TransposeLayer>
Finish() {
9261 const auto end = fbb_.EndTable(start_);
9262 auto o = flatbuffers::Offset<TransposeLayer>(end);
9268 flatbuffers::FlatBufferBuilder &_fbb,
9269 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9270 flatbuffers::Offset<armnnSerializer::TransposeDescriptor> descriptor = 0) {
9274 return builder_.
Finish();
9277 struct TransposeDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9279 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9283 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DIMMAPPINGS);
9285 bool Verify(flatbuffers::Verifier &verifier)
const {
9286 return VerifyTableStart(verifier) &&
9287 VerifyOffset(verifier, VT_DIMMAPPINGS) &&
9288 verifier.VerifyVector(dimMappings()) &&
9289 verifier.EndTable();
9295 flatbuffers::FlatBufferBuilder &
fbb_;
9298 fbb_.AddOffset(TransposeDescriptor::VT_DIMMAPPINGS, dimMappings);
9302 start_ = fbb_.StartTable();
9305 flatbuffers::Offset<TransposeDescriptor>
Finish() {
9306 const auto end = fbb_.EndTable(start_);
9307 auto o = flatbuffers::Offset<TransposeDescriptor>(end);
9313 flatbuffers::FlatBufferBuilder &_fbb,
9317 return builder_.
Finish();
9321 flatbuffers::FlatBufferBuilder &_fbb,
9322 const std::vector<uint32_t> *dimMappings =
nullptr) {
9323 auto dimMappings__ = dimMappings ? _fbb.CreateVector<uint32_t>(*dimMappings) : 0;
9329 struct ResizeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9331 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9335 const armnnSerializer::LayerBase *
base()
const {
9336 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9339 return GetPointer<const armnnSerializer::ResizeDescriptor *>(
VT_DESCRIPTOR);
9341 bool Verify(flatbuffers::Verifier &verifier)
const {
9342 return VerifyTableStart(verifier) &&
9343 VerifyOffset(verifier,
VT_BASE) &&
9344 verifier.VerifyTable(base()) &&
9346 verifier.VerifyTable(descriptor()) &&
9347 verifier.EndTable();
9353 flatbuffers::FlatBufferBuilder &
fbb_;
9355 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9358 void add_descriptor(flatbuffers::Offset<armnnSerializer::ResizeDescriptor> descriptor) {
9363 start_ = fbb_.StartTable();
9367 const auto end = fbb_.EndTable(start_);
9368 auto o = flatbuffers::Offset<ResizeLayer>(end);
9374 flatbuffers::FlatBufferBuilder &_fbb,
9375 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9376 flatbuffers::Offset<armnnSerializer::ResizeDescriptor> descriptor = 0) {
9380 return builder_.
Finish();
9383 struct ResizeDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9385 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9391 VT_HALFPIXELCENTERS = 14
9409 return GetField<uint8_t>(VT_HALFPIXELCENTERS, 0) != 0;
9411 bool Verify(flatbuffers::Verifier &verifier)
const {
9412 return VerifyTableStart(verifier) &&
9415 VerifyField<int8_t>(verifier,
VT_METHOD) &&
9418 VerifyField<uint8_t>(verifier, VT_HALFPIXELCENTERS) &&
9419 verifier.EndTable();
9425 flatbuffers::FlatBufferBuilder &
fbb_;
9443 fbb_.AddElement<uint8_t>(ResizeDescriptor::VT_HALFPIXELCENTERS,
static_cast<uint8_t
>(halfPixelCenters), 0);
9447 start_ = fbb_.StartTable();
9450 flatbuffers::Offset<ResizeDescriptor>
Finish() {
9451 const auto end = fbb_.EndTable(start_);
9452 auto o = flatbuffers::Offset<ResizeDescriptor>(end);
9458 flatbuffers::FlatBufferBuilder &_fbb,
9459 uint32_t targetHeight = 0,
9460 uint32_t targetWidth = 0,
9463 bool alignCorners =
false,
9464 bool halfPixelCenters =
false) {
9472 return builder_.
Finish();
9475 struct StackLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9477 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9481 const armnnSerializer::LayerBase *
base()
const {
9482 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9485 return GetPointer<const armnnSerializer::StackDescriptor *>(
VT_DESCRIPTOR);
9487 bool Verify(flatbuffers::Verifier &verifier)
const {
9488 return VerifyTableStart(verifier) &&
9489 VerifyOffset(verifier,
VT_BASE) &&
9490 verifier.VerifyTable(base()) &&
9492 verifier.VerifyTable(descriptor()) &&
9493 verifier.EndTable();
9499 flatbuffers::FlatBufferBuilder &
fbb_;
9501 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9504 void add_descriptor(flatbuffers::Offset<armnnSerializer::StackDescriptor> descriptor) {
9509 start_ = fbb_.StartTable();
9513 const auto end = fbb_.EndTable(start_);
9514 auto o = flatbuffers::Offset<StackLayer>(end);
9520 flatbuffers::FlatBufferBuilder &_fbb,
9521 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9522 flatbuffers::Offset<armnnSerializer::StackDescriptor> descriptor = 0) {
9526 return builder_.
Finish();
9529 struct StackDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9531 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9537 return GetField<uint32_t>(
VT_AXIS, 0);
9543 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_INPUTSHAPE);
9545 bool Verify(flatbuffers::Verifier &verifier)
const {
9546 return VerifyTableStart(verifier) &&
9547 VerifyField<uint32_t>(verifier,
VT_AXIS) &&
9549 VerifyOffset(verifier, VT_INPUTSHAPE) &&
9550 verifier.VerifyVector(inputShape()) &&
9551 verifier.EndTable();
9557 flatbuffers::FlatBufferBuilder &
fbb_;
9566 fbb_.AddOffset(StackDescriptor::VT_INPUTSHAPE, inputShape);
9570 start_ = fbb_.StartTable();
9573 flatbuffers::Offset<StackDescriptor>
Finish() {
9574 const auto end = fbb_.EndTable(start_);
9575 auto o = flatbuffers::Offset<StackDescriptor>(end);
9581 flatbuffers::FlatBufferBuilder &_fbb,
9583 uint32_t numInputs = 0,
9589 return builder_.
Finish();
9593 flatbuffers::FlatBufferBuilder &_fbb,
9595 uint32_t numInputs = 0,
9596 const std::vector<uint32_t> *inputShape =
nullptr) {
9597 auto inputShape__ = inputShape ? _fbb.CreateVector<uint32_t>(*inputShape) : 0;
9605 struct StandInDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9607 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9615 return GetField<uint32_t>(VT_NUMOUTPUTS, 0);
9617 bool Verify(flatbuffers::Verifier &verifier)
const {
9618 return VerifyTableStart(verifier) &&
9620 VerifyField<uint32_t>(verifier, VT_NUMOUTPUTS) &&
9621 verifier.EndTable();
9627 flatbuffers::FlatBufferBuilder &
fbb_;
9633 fbb_.AddElement<uint32_t>(StandInDescriptor::VT_NUMOUTPUTS, numOutputs, 0);
9637 start_ = fbb_.StartTable();
9640 flatbuffers::Offset<StandInDescriptor>
Finish() {
9641 const auto end = fbb_.EndTable(start_);
9642 auto o = flatbuffers::Offset<StandInDescriptor>(end);
9648 flatbuffers::FlatBufferBuilder &_fbb,
9649 uint32_t numInputs = 0,
9650 uint32_t numOutputs = 0) {
9654 return builder_.
Finish();
9657 struct StandInLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9659 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9663 const armnnSerializer::LayerBase *
base()
const {
9664 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9667 return GetPointer<const armnnSerializer::StandInDescriptor *>(
VT_DESCRIPTOR);
9669 bool Verify(flatbuffers::Verifier &verifier)
const {
9670 return VerifyTableStart(verifier) &&
9671 VerifyOffset(verifier,
VT_BASE) &&
9672 verifier.VerifyTable(base()) &&
9674 verifier.VerifyTable(descriptor()) &&
9675 verifier.EndTable();
9681 flatbuffers::FlatBufferBuilder &
fbb_;
9683 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9686 void add_descriptor(flatbuffers::Offset<armnnSerializer::StandInDescriptor> descriptor) {
9691 start_ = fbb_.StartTable();
9695 const auto end = fbb_.EndTable(start_);
9696 auto o = flatbuffers::Offset<StandInLayer>(end);
9702 flatbuffers::FlatBufferBuilder &_fbb,
9703 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9704 flatbuffers::Offset<armnnSerializer::StandInDescriptor> descriptor = 0) {
9708 return builder_.
Finish();
9711 struct RankLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9713 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9716 const armnnSerializer::LayerBase *
base()
const {
9717 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9719 bool Verify(flatbuffers::Verifier &verifier)
const {
9720 return VerifyTableStart(verifier) &&
9721 VerifyOffset(verifier,
VT_BASE) &&
9722 verifier.VerifyTable(base()) &&
9723 verifier.EndTable();
9729 flatbuffers::FlatBufferBuilder &
fbb_;
9731 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9736 start_ = fbb_.StartTable();
9740 const auto end = fbb_.EndTable(start_);
9741 auto o = flatbuffers::Offset<RankLayer>(end);
9747 flatbuffers::FlatBufferBuilder &_fbb,
9748 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
9751 return builder_.
Finish();
9754 struct ReduceLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9756 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9760 const armnnSerializer::LayerBase *
base()
const {
9761 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9764 return GetPointer<const armnnSerializer::ReduceDescriptor *>(
VT_DESCRIPTOR);
9766 bool Verify(flatbuffers::Verifier &verifier)
const {
9767 return VerifyTableStart(verifier) &&
9768 VerifyOffset(verifier,
VT_BASE) &&
9769 verifier.VerifyTable(base()) &&
9771 verifier.VerifyTable(descriptor()) &&
9772 verifier.EndTable();
9778 flatbuffers::FlatBufferBuilder &
fbb_;
9780 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9783 void add_descriptor(flatbuffers::Offset<armnnSerializer::ReduceDescriptor> descriptor) {
9788 start_ = fbb_.StartTable();
9792 const auto end = fbb_.EndTable(start_);
9793 auto o = flatbuffers::Offset<ReduceLayer>(end);
9799 flatbuffers::FlatBufferBuilder &_fbb,
9800 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9801 flatbuffers::Offset<armnnSerializer::ReduceDescriptor> descriptor = 0) {
9805 return builder_.
Finish();
9808 struct ReduceDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9810 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9813 VT_REDUCEOPERATION = 8
9818 const flatbuffers::Vector<uint32_t> *
axis()
const {
9819 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_AXIS);
9824 bool Verify(flatbuffers::Verifier &verifier)
const {
9825 return VerifyTableStart(verifier) &&
9827 VerifyOffset(verifier,
VT_AXIS) &&
9828 verifier.VerifyVector(axis()) &&
9829 VerifyField<int8_t>(verifier, VT_REDUCEOPERATION) &&
9830 verifier.EndTable();
9836 flatbuffers::FlatBufferBuilder &
fbb_;
9845 fbb_.AddElement<int8_t>(ReduceDescriptor::VT_REDUCEOPERATION,
static_cast<int8_t
>(reduceOperation), 0);
9849 start_ = fbb_.StartTable();
9852 flatbuffers::Offset<ReduceDescriptor>
Finish() {
9853 const auto end = fbb_.EndTable(start_);
9854 auto o = flatbuffers::Offset<ReduceDescriptor>(end);
9860 flatbuffers::FlatBufferBuilder &_fbb,
9861 bool keepDims =
false,
9868 return builder_.
Finish();
9872 flatbuffers::FlatBufferBuilder &_fbb,
9873 bool keepDims =
false,
9874 const std::vector<uint32_t> *axis =
nullptr,
9876 auto axis__ = axis ? _fbb.CreateVector<uint32_t>(*axis) : 0;
9886 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9918 return GetField<uint8_t>(VT_TIMEMAJOR, 0) != 0;
9920 bool Verify(flatbuffers::Verifier &verifier)
const {
9921 return VerifyTableStart(verifier) &&
9929 VerifyField<uint8_t>(verifier, VT_TIMEMAJOR) &&
9930 verifier.EndTable();
9936 flatbuffers::FlatBufferBuilder &
fbb_;
9960 fbb_.AddElement<uint8_t>(UnidirectionalSequenceLstmDescriptor::VT_TIMEMAJOR,
static_cast<uint8_t
>(timeMajor), 0);
9964 start_ = fbb_.StartTable();
9967 flatbuffers::Offset<UnidirectionalSequenceLstmDescriptor>
Finish() {
9968 const auto end = fbb_.EndTable(start_);
9969 auto o = flatbuffers::Offset<UnidirectionalSequenceLstmDescriptor>(end);
9975 flatbuffers::FlatBufferBuilder &_fbb,
9976 uint32_t activationFunc = 0,
9977 float clippingThresCell = 0.0f,
9978 float clippingThresProj = 0.0f,
9979 bool cifgEnabled =
true,
9980 bool peepholeEnabled =
false,
9981 bool projectionEnabled =
false,
9982 bool layerNormEnabled =
false,
9983 bool timeMajor =
false) {
9993 return builder_.
Finish();
9996 struct UnidirectionalSequenceLstmLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9998 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10003 const armnnSerializer::LayerBase *
base()
const {
10004 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
10007 return GetPointer<const armnnSerializer::UnidirectionalSequenceLstmDescriptor *>(
VT_DESCRIPTOR);
10010 return GetPointer<const armnnSerializer::LstmInputParams *>(VT_INPUTPARAMS);
10012 bool Verify(flatbuffers::Verifier &verifier)
const {
10013 return VerifyTableStart(verifier) &&
10014 VerifyOffset(verifier,
VT_BASE) &&
10015 verifier.VerifyTable(base()) &&
10017 verifier.VerifyTable(descriptor()) &&
10018 VerifyOffset(verifier, VT_INPUTPARAMS) &&
10019 verifier.VerifyTable(inputParams()) &&
10020 verifier.EndTable();
10025 typedef UnidirectionalSequenceLstmLayer
Table;
10028 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
10031 void add_descriptor(flatbuffers::Offset<armnnSerializer::UnidirectionalSequenceLstmDescriptor> descriptor) {
10035 fbb_.AddOffset(UnidirectionalSequenceLstmLayer::VT_INPUTPARAMS, inputParams);
10039 start_ = fbb_.StartTable();
10042 flatbuffers::Offset<UnidirectionalSequenceLstmLayer>
Finish() {
10043 const auto end = fbb_.EndTable(start_);
10044 auto o = flatbuffers::Offset<UnidirectionalSequenceLstmLayer>(end);
10050 flatbuffers::FlatBufferBuilder &_fbb,
10051 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
10052 flatbuffers::Offset<armnnSerializer::UnidirectionalSequenceLstmDescriptor> descriptor = 0,
10053 flatbuffers::Offset<armnnSerializer::LstmInputParams> inputParams = 0) {
10058 return builder_.
Finish();
10061 struct AnyLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
10063 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10071 return GetPointer<const void *>(VT_LAYER);
10073 template<
typename T>
const T *layer_as()
const;
10272 bool Verify(flatbuffers::Verifier &verifier)
const {
10273 return VerifyTableStart(verifier) &&
10275 VerifyOffset(verifier, VT_LAYER) &&
10277 verifier.EndTable();
10281 template<>
inline const armnnSerializer::ActivationLayer *AnyLayer::layer_as<armnnSerializer::ActivationLayer>()
const {
10282 return layer_as_ActivationLayer();
10285 template<>
inline const armnnSerializer::AdditionLayer *AnyLayer::layer_as<armnnSerializer::AdditionLayer>()
const {
10286 return layer_as_AdditionLayer();
10289 template<>
inline const armnnSerializer::BatchToSpaceNdLayer *AnyLayer::layer_as<armnnSerializer::BatchToSpaceNdLayer>()
const {
10290 return layer_as_BatchToSpaceNdLayer();
10293 template<>
inline const armnnSerializer::BatchNormalizationLayer *AnyLayer::layer_as<armnnSerializer::BatchNormalizationLayer>()
const {
10294 return layer_as_BatchNormalizationLayer();
10297 template<>
inline const armnnSerializer::ConstantLayer *AnyLayer::layer_as<armnnSerializer::ConstantLayer>()
const {
10298 return layer_as_ConstantLayer();
10301 template<>
inline const armnnSerializer::Convolution2dLayer *AnyLayer::layer_as<armnnSerializer::Convolution2dLayer>()
const {
10302 return layer_as_Convolution2dLayer();
10305 template<>
inline const armnnSerializer::DepthwiseConvolution2dLayer *AnyLayer::layer_as<armnnSerializer::DepthwiseConvolution2dLayer>()
const {
10306 return layer_as_DepthwiseConvolution2dLayer();
10309 template<>
inline const armnnSerializer::FullyConnectedLayer *AnyLayer::layer_as<armnnSerializer::FullyConnectedLayer>()
const {
10310 return layer_as_FullyConnectedLayer();
10313 template<>
inline const armnnSerializer::InputLayer *AnyLayer::layer_as<armnnSerializer::InputLayer>()
const {
10314 return layer_as_InputLayer();
10317 template<>
inline const armnnSerializer::MultiplicationLayer *AnyLayer::layer_as<armnnSerializer::MultiplicationLayer>()
const {
10318 return layer_as_MultiplicationLayer();
10321 template<>
inline const armnnSerializer::OutputLayer *AnyLayer::layer_as<armnnSerializer::OutputLayer>()
const {
10322 return layer_as_OutputLayer();
10325 template<>
inline const armnnSerializer::PermuteLayer *AnyLayer::layer_as<armnnSerializer::PermuteLayer>()
const {
10326 return layer_as_PermuteLayer();
10329 template<>
inline const armnnSerializer::Pooling2dLayer *AnyLayer::layer_as<armnnSerializer::Pooling2dLayer>()
const {
10330 return layer_as_Pooling2dLayer();
10333 template<>
inline const armnnSerializer::ReshapeLayer *AnyLayer::layer_as<armnnSerializer::ReshapeLayer>()
const {
10334 return layer_as_ReshapeLayer();
10337 template<>
inline const armnnSerializer::SoftmaxLayer *AnyLayer::layer_as<armnnSerializer::SoftmaxLayer>()
const {
10338 return layer_as_SoftmaxLayer();
10341 template<>
inline const armnnSerializer::SpaceToBatchNdLayer *AnyLayer::layer_as<armnnSerializer::SpaceToBatchNdLayer>()
const {
10342 return layer_as_SpaceToBatchNdLayer();
10345 template<>
inline const armnnSerializer::DivisionLayer *AnyLayer::layer_as<armnnSerializer::DivisionLayer>()
const {
10346 return layer_as_DivisionLayer();
10349 template<>
inline const armnnSerializer::MinimumLayer *AnyLayer::layer_as<armnnSerializer::MinimumLayer>()
const {
10350 return layer_as_MinimumLayer();
10353 template<>
inline const armnnSerializer::EqualLayer *AnyLayer::layer_as<armnnSerializer::EqualLayer>()
const {
10354 return layer_as_EqualLayer();
10357 template<>
inline const armnnSerializer::MaximumLayer *AnyLayer::layer_as<armnnSerializer::MaximumLayer>()
const {
10358 return layer_as_MaximumLayer();
10361 template<>
inline const armnnSerializer::NormalizationLayer *AnyLayer::layer_as<armnnSerializer::NormalizationLayer>()
const {
10362 return layer_as_NormalizationLayer();
10365 template<>
inline const armnnSerializer::PadLayer *AnyLayer::layer_as<armnnSerializer::PadLayer>()
const {
10366 return layer_as_PadLayer();
10369 template<>
inline const armnnSerializer::RsqrtLayer *AnyLayer::layer_as<armnnSerializer::RsqrtLayer>()
const {
10370 return layer_as_RsqrtLayer();
10373 template<>
inline const armnnSerializer::FloorLayer *AnyLayer::layer_as<armnnSerializer::FloorLayer>()
const {
10374 return layer_as_FloorLayer();
10377 template<>
inline const armnnSerializer::GreaterLayer *AnyLayer::layer_as<armnnSerializer::GreaterLayer>()
const {
10378 return layer_as_GreaterLayer();
10381 template<>
inline const armnnSerializer::ResizeBilinearLayer *AnyLayer::layer_as<armnnSerializer::ResizeBilinearLayer>()
const {
10382 return layer_as_ResizeBilinearLayer();
10385 template<>
inline const armnnSerializer::SubtractionLayer *AnyLayer::layer_as<armnnSerializer::SubtractionLayer>()
const {
10386 return layer_as_SubtractionLayer();
10389 template<>
inline const armnnSerializer::StridedSliceLayer *AnyLayer::layer_as<armnnSerializer::StridedSliceLayer>()
const {
10390 return layer_as_StridedSliceLayer();
10393 template<>
inline const armnnSerializer::GatherLayer *AnyLayer::layer_as<armnnSerializer::GatherLayer>()
const {
10394 return layer_as_GatherLayer();
10397 template<>
inline const armnnSerializer::MeanLayer *AnyLayer::layer_as<armnnSerializer::MeanLayer>()
const {
10398 return layer_as_MeanLayer();
10402 return layer_as_MergerLayer();
10405 template<>
inline const armnnSerializer::L2NormalizationLayer *AnyLayer::layer_as<armnnSerializer::L2NormalizationLayer>()
const {
10406 return layer_as_L2NormalizationLayer();
10409 template<>
inline const armnnSerializer::SplitterLayer *AnyLayer::layer_as<armnnSerializer::SplitterLayer>()
const {
10410 return layer_as_SplitterLayer();
10413 template<>
inline const armnnSerializer::DetectionPostProcessLayer *AnyLayer::layer_as<armnnSerializer::DetectionPostProcessLayer>()
const {
10414 return layer_as_DetectionPostProcessLayer();
10417 template<>
inline const armnnSerializer::LstmLayer *AnyLayer::layer_as<armnnSerializer::LstmLayer>()
const {
10418 return layer_as_LstmLayer();
10421 template<>
inline const armnnSerializer::QuantizedLstmLayer *AnyLayer::layer_as<armnnSerializer::QuantizedLstmLayer>()
const {
10422 return layer_as_QuantizedLstmLayer();
10425 template<>
inline const armnnSerializer::QuantizeLayer *AnyLayer::layer_as<armnnSerializer::QuantizeLayer>()
const {
10426 return layer_as_QuantizeLayer();
10429 template<>
inline const armnnSerializer::DequantizeLayer *AnyLayer::layer_as<armnnSerializer::DequantizeLayer>()
const {
10430 return layer_as_DequantizeLayer();
10433 template<>
inline const armnnSerializer::MergeLayer *AnyLayer::layer_as<armnnSerializer::MergeLayer>()
const {
10434 return layer_as_MergeLayer();
10437 template<>
inline const armnnSerializer::SwitchLayer *AnyLayer::layer_as<armnnSerializer::SwitchLayer>()
const {
10438 return layer_as_SwitchLayer();
10441 template<>
inline const armnnSerializer::ConcatLayer *AnyLayer::layer_as<armnnSerializer::ConcatLayer>()
const {
10442 return layer_as_ConcatLayer();
10445 template<>
inline const armnnSerializer::SpaceToDepthLayer *AnyLayer::layer_as<armnnSerializer::SpaceToDepthLayer>()
const {
10446 return layer_as_SpaceToDepthLayer();
10449 template<>
inline const armnnSerializer::PreluLayer *AnyLayer::layer_as<armnnSerializer::PreluLayer>()
const {
10450 return layer_as_PreluLayer();
10453 template<>
inline const armnnSerializer::TransposeConvolution2dLayer *AnyLayer::layer_as<armnnSerializer::TransposeConvolution2dLayer>()
const {
10454 return layer_as_TransposeConvolution2dLayer();
10457 template<>
inline const armnnSerializer::ResizeLayer *AnyLayer::layer_as<armnnSerializer::ResizeLayer>()
const {
10458 return layer_as_ResizeLayer();
10461 template<>
inline const armnnSerializer::StackLayer *AnyLayer::layer_as<armnnSerializer::StackLayer>()
const {
10462 return layer_as_StackLayer();
10465 template<>
inline const armnnSerializer::AbsLayer *AnyLayer::layer_as<armnnSerializer::AbsLayer>()
const {
10466 return layer_as_AbsLayer();
10469 template<>
inline const armnnSerializer::ArgMinMaxLayer *AnyLayer::layer_as<armnnSerializer::ArgMinMaxLayer>()
const {
10470 return layer_as_ArgMinMaxLayer();
10473 template<>
inline const armnnSerializer::SliceLayer *AnyLayer::layer_as<armnnSerializer::SliceLayer>()
const {
10474 return layer_as_SliceLayer();
10477 template<>
inline const armnnSerializer::DepthToSpaceLayer *AnyLayer::layer_as<armnnSerializer::DepthToSpaceLayer>()
const {
10478 return layer_as_DepthToSpaceLayer();
10481 template<>
inline const armnnSerializer::InstanceNormalizationLayer *AnyLayer::layer_as<armnnSerializer::InstanceNormalizationLayer>()
const {
10482 return layer_as_InstanceNormalizationLayer();
10485 template<>
inline const armnnSerializer::LogSoftmaxLayer *AnyLayer::layer_as<armnnSerializer::LogSoftmaxLayer>()
const {
10486 return layer_as_LogSoftmaxLayer();
10489 template<>
inline const armnnSerializer::ComparisonLayer *AnyLayer::layer_as<armnnSerializer::ComparisonLayer>()
const {
10490 return layer_as_ComparisonLayer();
10493 template<>
inline const armnnSerializer::StandInLayer *AnyLayer::layer_as<armnnSerializer::StandInLayer>()
const {
10494 return layer_as_StandInLayer();
10497 template<>
inline const armnnSerializer::ElementwiseUnaryLayer *AnyLayer::layer_as<armnnSerializer::ElementwiseUnaryLayer>()
const {
10498 return layer_as_ElementwiseUnaryLayer();
10501 template<>
inline const armnnSerializer::TransposeLayer *AnyLayer::layer_as<armnnSerializer::TransposeLayer>()
const {
10502 return layer_as_TransposeLayer();
10505 template<>
inline const armnnSerializer::QLstmLayer *AnyLayer::layer_as<armnnSerializer::QLstmLayer>()
const {
10506 return layer_as_QLstmLayer();
10509 template<>
inline const armnnSerializer::FillLayer *AnyLayer::layer_as<armnnSerializer::FillLayer>()
const {
10510 return layer_as_FillLayer();
10513 template<>
inline const armnnSerializer::RankLayer *AnyLayer::layer_as<armnnSerializer::RankLayer>()
const {
10514 return layer_as_RankLayer();
10517 template<>
inline const armnnSerializer::LogicalBinaryLayer *AnyLayer::layer_as<armnnSerializer::LogicalBinaryLayer>()
const {
10518 return layer_as_LogicalBinaryLayer();
10521 template<>
inline const armnnSerializer::ReduceLayer *AnyLayer::layer_as<armnnSerializer::ReduceLayer>()
const {
10522 return layer_as_ReduceLayer();
10525 template<>
inline const armnnSerializer::CastLayer *AnyLayer::layer_as<armnnSerializer::CastLayer>()
const {
10526 return layer_as_CastLayer();
10529 template<>
inline const armnnSerializer::ShapeLayer *AnyLayer::layer_as<armnnSerializer::ShapeLayer>()
const {
10530 return layer_as_ShapeLayer();
10533 template<>
inline const armnnSerializer::UnidirectionalSequenceLstmLayer *AnyLayer::layer_as<armnnSerializer::UnidirectionalSequenceLstmLayer>()
const {
10534 return layer_as_UnidirectionalSequenceLstmLayer();
10537 template<>
inline const armnnSerializer::ChannelShuffleLayer *AnyLayer::layer_as<armnnSerializer::ChannelShuffleLayer>()
const {
10538 return layer_as_ChannelShuffleLayer();
10541 template<>
inline const armnnSerializer::Convolution3dLayer *AnyLayer::layer_as<armnnSerializer::Convolution3dLayer>()
const {
10542 return layer_as_Convolution3dLayer();
10553 fbb_.AddOffset(AnyLayer::VT_LAYER, layer);
10557 start_ = fbb_.StartTable();
10561 const auto end = fbb_.EndTable(start_);
10562 auto o = flatbuffers::Offset<AnyLayer>(end);
10568 flatbuffers::FlatBufferBuilder &_fbb,
10570 flatbuffers::Offset<void> layer = 0) {
10574 return builder_.
Finish();
10577 struct FeatureCompatibilityVersions FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
10579 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10582 VT_CONSTANTTENSORSASINPUTS = 8
10591 return GetField<uint32_t>(VT_CONSTANTTENSORSASINPUTS, 0);
10593 bool Verify(flatbuffers::Verifier &verifier)
const {
10594 return VerifyTableStart(verifier) &&
10597 VerifyField<uint32_t>(verifier, VT_CONSTANTTENSORSASINPUTS) &&
10598 verifier.EndTable();
10613 fbb_.AddElement<uint32_t>(FeatureCompatibilityVersions::VT_CONSTANTTENSORSASINPUTS, constantTensorsAsInputs, 0);
10617 start_ = fbb_.StartTable();
10620 flatbuffers::Offset<FeatureCompatibilityVersions>
Finish() {
10621 const auto end = fbb_.EndTable(start_);
10622 auto o = flatbuffers::Offset<FeatureCompatibilityVersions>(end);
10628 flatbuffers::FlatBufferBuilder &_fbb,
10629 uint32_t bindingIdsScheme = 0,
10630 uint32_t weightsLayoutScheme = 0,
10631 uint32_t constantTensorsAsInputs = 0) {
10636 return builder_.
Finish();
10639 struct SerializedGraph FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
10641 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10645 VT_FEATUREVERSIONS = 10
10647 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::AnyLayer>> *
layers()
const {
10648 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::AnyLayer>> *>(
VT_LAYERS);
10651 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_INPUTIDS);
10654 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_OUTPUTIDS);
10657 return GetPointer<const armnnSerializer::FeatureCompatibilityVersions *>(VT_FEATUREVERSIONS);
10659 bool Verify(flatbuffers::Verifier &verifier)
const {
10660 return VerifyTableStart(verifier) &&
10662 verifier.VerifyVector(layers()) &&
10663 verifier.VerifyVectorOfTables(layers()) &&
10665 verifier.VerifyVector(inputIds()) &&
10667 verifier.VerifyVector(outputIds()) &&
10668 VerifyOffset(verifier, VT_FEATUREVERSIONS) &&
10669 verifier.VerifyTable(featureVersions()) &&
10670 verifier.EndTable();
10688 fbb_.AddOffset(SerializedGraph::VT_FEATUREVERSIONS, featureVersions);
10692 start_ = fbb_.StartTable();
10696 const auto end = fbb_.EndTable(start_);
10697 auto o = flatbuffers::Offset<SerializedGraph>(end);
10703 flatbuffers::FlatBufferBuilder &_fbb,
10704 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::AnyLayer>>> layers = 0,
10707 flatbuffers::Offset<armnnSerializer::FeatureCompatibilityVersions> featureVersions = 0) {
10713 return builder_.
Finish();
10717 flatbuffers::FlatBufferBuilder &_fbb,
10718 const std::vector<flatbuffers::Offset<armnnSerializer::AnyLayer>> *layers =
nullptr,
10719 const std::vector<int32_t> *inputIds =
nullptr,
10720 const std::vector<int32_t> *outputIds =
nullptr,
10721 flatbuffers::Offset<armnnSerializer::FeatureCompatibilityVersions> featureVersions = 0) {
10722 auto layers__ = layers ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::AnyLayer>>(*layers) : 0;
10723 auto inputIds__ = inputIds ? _fbb.CreateVector<int32_t>(*inputIds) : 0;
10724 auto outputIds__ = outputIds ? _fbb.CreateVector<int32_t>(*outputIds) : 0;
10739 auto ptr =
reinterpret_cast<const armnnSerializer::ByteData *
>(obj);
10740 return verifier.VerifyTable(ptr);
10743 auto ptr =
reinterpret_cast<const armnnSerializer::ShortData *
>(obj);
10744 return verifier.VerifyTable(ptr);
10747 auto ptr =
reinterpret_cast<const armnnSerializer::IntData *
>(obj);
10748 return verifier.VerifyTable(ptr);
10751 auto ptr =
reinterpret_cast<const armnnSerializer::LongData *
>(obj);
10752 return verifier.VerifyTable(ptr);
10754 default:
return true;
10758 inline bool VerifyConstTensorDataVector(flatbuffers::Verifier &verifier,
const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
const flatbuffers::Vector<uint8_t> *types) {
10759 if (!values || !types)
return !values && !types;
10760 if (values->size() != types->size())
return false;
10761 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
10776 auto ptr =
reinterpret_cast<const armnnSerializer::ActivationLayer *
>(obj);
10777 return verifier.VerifyTable(ptr);
10780 auto ptr =
reinterpret_cast<const armnnSerializer::AdditionLayer *
>(obj);
10781 return verifier.VerifyTable(ptr);
10784 auto ptr =
reinterpret_cast<const armnnSerializer::BatchToSpaceNdLayer *
>(obj);
10785 return verifier.VerifyTable(ptr);
10788 auto ptr =
reinterpret_cast<const armnnSerializer::BatchNormalizationLayer *
>(obj);
10789 return verifier.VerifyTable(ptr);
10792 auto ptr =
reinterpret_cast<const armnnSerializer::ConstantLayer *
>(obj);
10793 return verifier.VerifyTable(ptr);
10796 auto ptr =
reinterpret_cast<const armnnSerializer::Convolution2dLayer *
>(obj);
10797 return verifier.VerifyTable(ptr);
10800 auto ptr =
reinterpret_cast<const armnnSerializer::DepthwiseConvolution2dLayer *
>(obj);
10801 return verifier.VerifyTable(ptr);
10804 auto ptr =
reinterpret_cast<const armnnSerializer::FullyConnectedLayer *
>(obj);
10805 return verifier.VerifyTable(ptr);
10808 auto ptr =
reinterpret_cast<const armnnSerializer::InputLayer *
>(obj);
10809 return verifier.VerifyTable(ptr);
10812 auto ptr =
reinterpret_cast<const armnnSerializer::MultiplicationLayer *
>(obj);
10813 return verifier.VerifyTable(ptr);
10816 auto ptr =
reinterpret_cast<const armnnSerializer::OutputLayer *
>(obj);
10817 return verifier.VerifyTable(ptr);
10820 auto ptr =
reinterpret_cast<const armnnSerializer::PermuteLayer *
>(obj);
10821 return verifier.VerifyTable(ptr);
10824 auto ptr =
reinterpret_cast<const armnnSerializer::Pooling2dLayer *
>(obj);
10825 return verifier.VerifyTable(ptr);
10828 auto ptr =
reinterpret_cast<const armnnSerializer::ReshapeLayer *
>(obj);
10829 return verifier.VerifyTable(ptr);
10832 auto ptr =
reinterpret_cast<const armnnSerializer::SoftmaxLayer *
>(obj);
10833 return verifier.VerifyTable(ptr);
10836 auto ptr =
reinterpret_cast<const armnnSerializer::SpaceToBatchNdLayer *
>(obj);
10837 return verifier.VerifyTable(ptr);
10840 auto ptr =
reinterpret_cast<const armnnSerializer::DivisionLayer *
>(obj);
10841 return verifier.VerifyTable(ptr);
10844 auto ptr =
reinterpret_cast<const armnnSerializer::MinimumLayer *
>(obj);
10845 return verifier.VerifyTable(ptr);
10848 auto ptr =
reinterpret_cast<const armnnSerializer::EqualLayer *
>(obj);
10849 return verifier.VerifyTable(ptr);
10852 auto ptr =
reinterpret_cast<const armnnSerializer::MaximumLayer *
>(obj);
10853 return verifier.VerifyTable(ptr);
10856 auto ptr =
reinterpret_cast<const armnnSerializer::NormalizationLayer *
>(obj);
10857 return verifier.VerifyTable(ptr);
10860 auto ptr =
reinterpret_cast<const armnnSerializer::PadLayer *
>(obj);
10861 return verifier.VerifyTable(ptr);
10864 auto ptr =
reinterpret_cast<const armnnSerializer::RsqrtLayer *
>(obj);
10865 return verifier.VerifyTable(ptr);
10868 auto ptr =
reinterpret_cast<const armnnSerializer::FloorLayer *
>(obj);
10869 return verifier.VerifyTable(ptr);
10872 auto ptr =
reinterpret_cast<const armnnSerializer::GreaterLayer *
>(obj);
10873 return verifier.VerifyTable(ptr);
10876 auto ptr =
reinterpret_cast<const armnnSerializer::ResizeBilinearLayer *
>(obj);
10877 return verifier.VerifyTable(ptr);
10880 auto ptr =
reinterpret_cast<const armnnSerializer::SubtractionLayer *
>(obj);
10881 return verifier.VerifyTable(ptr);
10884 auto ptr =
reinterpret_cast<const armnnSerializer::StridedSliceLayer *
>(obj);
10885 return verifier.VerifyTable(ptr);
10888 auto ptr =
reinterpret_cast<const armnnSerializer::GatherLayer *
>(obj);
10889 return verifier.VerifyTable(ptr);
10892 auto ptr =
reinterpret_cast<const armnnSerializer::MeanLayer *
>(obj);
10893 return verifier.VerifyTable(ptr);
10897 return verifier.VerifyTable(ptr);
10900 auto ptr =
reinterpret_cast<const armnnSerializer::L2NormalizationLayer *
>(obj);
10901 return verifier.VerifyTable(ptr);
10904 auto ptr =
reinterpret_cast<const armnnSerializer::SplitterLayer *
>(obj);
10905 return verifier.VerifyTable(ptr);
10908 auto ptr =
reinterpret_cast<const armnnSerializer::DetectionPostProcessLayer *
>(obj);
10909 return verifier.VerifyTable(ptr);
10912 auto ptr =
reinterpret_cast<const armnnSerializer::LstmLayer *
>(obj);
10913 return verifier.VerifyTable(ptr);
10916 auto ptr =
reinterpret_cast<const armnnSerializer::QuantizedLstmLayer *
>(obj);
10917 return verifier.VerifyTable(ptr);
10920 auto ptr =
reinterpret_cast<const armnnSerializer::QuantizeLayer *
>(obj);
10921 return verifier.VerifyTable(ptr);
10924 auto ptr =
reinterpret_cast<const armnnSerializer::DequantizeLayer *
>(obj);
10925 return verifier.VerifyTable(ptr);
10928 auto ptr =
reinterpret_cast<const armnnSerializer::MergeLayer *
>(obj);
10929 return verifier.VerifyTable(ptr);
10932 auto ptr =
reinterpret_cast<const armnnSerializer::SwitchLayer *
>(obj);
10933 return verifier.VerifyTable(ptr);
10936 auto ptr =
reinterpret_cast<const armnnSerializer::ConcatLayer *
>(obj);
10937 return verifier.VerifyTable(ptr);
10940 auto ptr =
reinterpret_cast<const armnnSerializer::SpaceToDepthLayer *
>(obj);
10941 return verifier.VerifyTable(ptr);
10944 auto ptr =
reinterpret_cast<const armnnSerializer::PreluLayer *
>(obj);
10945 return verifier.VerifyTable(ptr);
10948 auto ptr =
reinterpret_cast<const armnnSerializer::TransposeConvolution2dLayer *
>(obj);
10949 return verifier.VerifyTable(ptr);
10952 auto ptr =
reinterpret_cast<const armnnSerializer::ResizeLayer *
>(obj);
10953 return verifier.VerifyTable(ptr);
10956 auto ptr =
reinterpret_cast<const armnnSerializer::StackLayer *
>(obj);
10957 return verifier.VerifyTable(ptr);
10960 auto ptr =
reinterpret_cast<const armnnSerializer::AbsLayer *
>(obj);
10961 return verifier.VerifyTable(ptr);
10964 auto ptr =
reinterpret_cast<const armnnSerializer::ArgMinMaxLayer *
>(obj);
10965 return verifier.VerifyTable(ptr);
10968 auto ptr =
reinterpret_cast<const armnnSerializer::SliceLayer *
>(obj);
10969 return verifier.VerifyTable(ptr);
10972 auto ptr =
reinterpret_cast<const armnnSerializer::DepthToSpaceLayer *
>(obj);
10973 return verifier.VerifyTable(ptr);
10976 auto ptr =
reinterpret_cast<const armnnSerializer::InstanceNormalizationLayer *
>(obj);
10977 return verifier.VerifyTable(ptr);
10980 auto ptr =
reinterpret_cast<const armnnSerializer::LogSoftmaxLayer *
>(obj);
10981 return verifier.VerifyTable(ptr);
10984 auto ptr =
reinterpret_cast<const armnnSerializer::ComparisonLayer *
>(obj);
10985 return verifier.VerifyTable(ptr);
10988 auto ptr =
reinterpret_cast<const armnnSerializer::StandInLayer *
>(obj);
10989 return verifier.VerifyTable(ptr);
10992 auto ptr =
reinterpret_cast<const armnnSerializer::ElementwiseUnaryLayer *
>(obj);
10993 return verifier.VerifyTable(ptr);
10996 auto ptr =
reinterpret_cast<const armnnSerializer::TransposeLayer *
>(obj);
10997 return verifier.VerifyTable(ptr);
11000 auto ptr =
reinterpret_cast<const armnnSerializer::QLstmLayer *
>(obj);
11001 return verifier.VerifyTable(ptr);
11004 auto ptr =
reinterpret_cast<const armnnSerializer::FillLayer *
>(obj);
11005 return verifier.VerifyTable(ptr);
11008 auto ptr =
reinterpret_cast<const armnnSerializer::RankLayer *
>(obj);
11009 return verifier.VerifyTable(ptr);
11012 auto ptr =
reinterpret_cast<const armnnSerializer::LogicalBinaryLayer *
>(obj);
11013 return verifier.VerifyTable(ptr);
11016 auto ptr =
reinterpret_cast<const armnnSerializer::ReduceLayer *
>(obj);
11017 return verifier.VerifyTable(ptr);
11020 auto ptr =
reinterpret_cast<const armnnSerializer::CastLayer *
>(obj);
11021 return verifier.VerifyTable(ptr);
11024 auto ptr =
reinterpret_cast<const armnnSerializer::ShapeLayer *
>(obj);
11025 return verifier.VerifyTable(ptr);
11028 auto ptr =
reinterpret_cast<const armnnSerializer::UnidirectionalSequenceLstmLayer *
>(obj);
11029 return verifier.VerifyTable(ptr);
11032 auto ptr =
reinterpret_cast<const armnnSerializer::ChannelShuffleLayer *
>(obj);
11033 return verifier.VerifyTable(ptr);
11036 auto ptr =
reinterpret_cast<const armnnSerializer::Convolution3dLayer *
>(obj);
11037 return verifier.VerifyTable(ptr);
11039 default:
return true;
11043 inline bool VerifyLayerVector(flatbuffers::Verifier &verifier,
const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
const flatbuffers::Vector<uint8_t> *types) {
11044 if (!values || !types)
return !values && !types;
11045 if (values->size() != types->size())
return false;
11046 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
11048 verifier, values->Get(i), types->GetEnum<
Layer>(i))) {
11056 return flatbuffers::GetRoot<armnnSerializer::SerializedGraph>(buf);
11060 return flatbuffers::GetSizePrefixedRoot<armnnSerializer::SerializedGraph>(buf);
11068 return flatbuffers::BufferHasIdentifier(
11073 flatbuffers::Verifier &verifier) {
11078 flatbuffers::Verifier &verifier) {
11087 flatbuffers::FlatBufferBuilder &fbb,
11088 flatbuffers::Offset<armnnSerializer::SerializedGraph> root) {
11093 flatbuffers::FlatBufferBuilder &fbb,
11094 flatbuffers::Offset<armnnSerializer::SerializedGraph> root) {
11100 #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_
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
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)
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()
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_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
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
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()
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()
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)
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()
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_
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)
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
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()
flatbuffers::uoffset_t start_
const PaddingMode(& EnumValuesPaddingMode())[3]
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_strideZ(uint32_t strideZ)
QuantizedLstmLayerBuilder Builder
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_
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
void add_scaleY(float scaleY)
void add_dataType(armnnSerializer::DataType dataType)
const char * SerializedGraphIdentifier()
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::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
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)
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)
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)
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_
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)
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
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::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)
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)
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::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)
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
const LayerType(& EnumValuesLayerType())[66]
ElementwiseUnaryLayer Table
void add_targetShape(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> targetShape)
flatbuffers::Offset< ArgMinMaxDescriptor > Finish()
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_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)
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)
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
const Layer(& EnumValuesLayer())[67]
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::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)