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 ComparisonDescriptor;
69 struct ComparisonDescriptorBuilder;
71 struct ComparisonLayer;
72 struct ComparisonLayerBuilder;
75 struct ConstantLayerBuilder;
77 struct Convolution2dLayer;
78 struct Convolution2dLayerBuilder;
80 struct Convolution2dDescriptor;
81 struct Convolution2dDescriptorBuilder;
83 struct DepthToSpaceLayer;
84 struct DepthToSpaceLayerBuilder;
87 struct DepthToSpaceDescriptorBuilder;
90 struct DivisionLayerBuilder;
92 struct ElementwiseUnaryDescriptor;
93 struct ElementwiseUnaryDescriptorBuilder;
95 struct ElementwiseUnaryLayer;
96 struct ElementwiseUnaryLayerBuilder;
99 struct EqualLayerBuilder;
102 struct FillLayerBuilder;
104 struct FillDescriptor;
105 struct FillDescriptorBuilder;
108 struct FloorLayerBuilder;
110 struct FullyConnectedLayer;
111 struct FullyConnectedLayerBuilder;
113 struct FullyConnectedDescriptor;
114 struct FullyConnectedDescriptorBuilder;
117 struct GatherLayerBuilder;
119 struct GatherDescriptor;
120 struct GatherDescriptorBuilder;
123 struct GreaterLayerBuilder;
126 struct InputLayerBuilder;
128 struct InstanceNormalizationLayer;
129 struct InstanceNormalizationLayerBuilder;
131 struct InstanceNormalizationDescriptor;
132 struct InstanceNormalizationDescriptorBuilder;
134 struct LogSoftmaxLayer;
135 struct LogSoftmaxLayerBuilder;
138 struct LogSoftmaxDescriptorBuilder;
140 struct L2NormalizationLayer;
141 struct L2NormalizationLayerBuilder;
143 struct L2NormalizationDescriptor;
144 struct L2NormalizationDescriptorBuilder;
146 struct LogicalBinaryDescriptor;
147 struct LogicalBinaryDescriptorBuilder;
149 struct LogicalBinaryLayer;
150 struct LogicalBinaryLayerBuilder;
153 struct MinimumLayerBuilder;
156 struct MaximumLayerBuilder;
158 struct MultiplicationLayer;
159 struct MultiplicationLayerBuilder;
161 struct Pooling2dLayer;
162 struct Pooling2dLayerBuilder;
164 struct Pooling2dDescriptor;
165 struct Pooling2dDescriptorBuilder;
167 struct QuantizeLayer;
168 struct QuantizeLayerBuilder;
171 struct SoftmaxLayerBuilder;
173 struct SoftmaxDescriptor;
174 struct SoftmaxDescriptorBuilder;
176 struct DepthwiseConvolution2dLayer;
177 struct DepthwiseConvolution2dLayerBuilder;
179 struct DepthwiseConvolution2dDescriptor;
180 struct DepthwiseConvolution2dDescriptorBuilder;
183 struct OutputLayerBuilder;
186 struct ReshapeLayerBuilder;
188 struct ReshapeDescriptor;
189 struct ReshapeDescriptorBuilder;
192 struct PermuteLayerBuilder;
194 struct PermuteDescriptor;
195 struct PermuteDescriptorBuilder;
198 struct ShapeLayerBuilder;
200 struct SpaceToBatchNdLayer;
201 struct SpaceToBatchNdLayerBuilder;
203 struct SpaceToBatchNdDescriptor;
204 struct SpaceToBatchNdDescriptorBuilder;
206 struct SpaceToDepthLayer;
207 struct SpaceToDepthLayerBuilder;
209 struct SpaceToDepthDescriptor;
210 struct SpaceToDepthDescriptorBuilder;
212 struct SubtractionLayer;
213 struct SubtractionLayerBuilder;
215 struct BatchToSpaceNdLayer;
216 struct BatchToSpaceNdLayerBuilder;
218 struct BatchToSpaceNdDescriptor;
219 struct BatchToSpaceNdDescriptorBuilder;
221 struct NormalizationLayer;
222 struct NormalizationLayerBuilder;
224 struct NormalizationDescriptor;
225 struct NormalizationDescriptorBuilder;
228 struct MeanLayerBuilder;
230 struct MeanDescriptor;
231 struct MeanDescriptorBuilder;
234 struct PadLayerBuilder;
236 struct PadDescriptor;
237 struct PadDescriptorBuilder;
240 struct RsqrtLayerBuilder;
242 struct BatchNormalizationLayer;
243 struct BatchNormalizationLayerBuilder;
245 struct BatchNormalizationDescriptor;
246 struct BatchNormalizationDescriptorBuilder;
248 struct ResizeBilinearLayer;
249 struct ResizeBilinearLayerBuilder;
251 struct ResizeBilinearDescriptor;
252 struct ResizeBilinearDescriptorBuilder;
255 struct SliceLayerBuilder;
257 struct SliceDescriptor;
258 struct SliceDescriptorBuilder;
260 struct StridedSliceLayer;
261 struct StridedSliceLayerBuilder;
263 struct StridedSliceDescriptor;
264 struct StridedSliceDescriptorBuilder;
267 struct ConcatLayerBuilder;
270 struct MergerLayerBuilder;
273 struct UintVectorBuilder;
275 struct OriginsDescriptor;
276 struct OriginsDescriptorBuilder;
278 struct ViewsDescriptor;
279 struct ViewsDescriptorBuilder;
281 struct SplitterLayer;
282 struct SplitterLayerBuilder;
284 struct DetectionPostProcessLayer;
285 struct DetectionPostProcessLayerBuilder;
287 struct DetectionPostProcessDescriptor;
288 struct DetectionPostProcessDescriptorBuilder;
290 struct LstmInputParams;
291 struct LstmInputParamsBuilder;
293 struct LstmDescriptor;
294 struct LstmDescriptorBuilder;
297 struct LstmLayerBuilder;
299 struct QLstmInputParams;
300 struct QLstmInputParamsBuilder;
302 struct QLstmDescriptor;
303 struct QLstmDescriptorBuilder;
306 struct QLstmLayerBuilder;
308 struct QuantizedLstmInputParams;
309 struct QuantizedLstmInputParamsBuilder;
311 struct QuantizedLstmLayer;
312 struct QuantizedLstmLayerBuilder;
314 struct DequantizeLayer;
315 struct DequantizeLayerBuilder;
318 struct MergeLayerBuilder;
321 struct SwitchLayerBuilder;
324 struct PreluLayerBuilder;
326 struct TransposeConvolution2dLayer;
327 struct TransposeConvolution2dLayerBuilder;
329 struct TransposeConvolution2dDescriptor;
330 struct TransposeConvolution2dDescriptorBuilder;
332 struct TransposeLayer;
333 struct TransposeLayerBuilder;
335 struct TransposeDescriptor;
336 struct TransposeDescriptorBuilder;
339 struct ResizeLayerBuilder;
341 struct ResizeDescriptor;
342 struct ResizeDescriptorBuilder;
345 struct StackLayerBuilder;
347 struct StackDescriptor;
348 struct StackDescriptorBuilder;
350 struct StandInDescriptor;
351 struct StandInDescriptorBuilder;
354 struct StandInLayerBuilder;
357 struct RankLayerBuilder;
360 struct ReduceLayerBuilder;
362 struct ReduceDescriptor;
363 struct ReduceDescriptorBuilder;
366 struct UnidirectionalSequenceLstmDescriptorBuilder;
368 struct UnidirectionalSequenceLstmLayer;
369 struct UnidirectionalSequenceLstmLayerBuilder;
372 struct AnyLayerBuilder;
374 struct FeatureCompatibilityVersions;
375 struct FeatureCompatibilityVersionsBuilder;
377 struct SerializedGraph;
378 struct SerializedGraphBuilder;
416 static const char *
const names[13] = {
436 const size_t index =
static_cast<size_t>(e);
456 static const char *
const names[3] = {
466 const size_t index =
static_cast<size_t>(e);
504 static const char *
const names[12] = {
523 const size_t index =
static_cast<size_t>(e);
543 static const char *
const names[3] = {
553 const size_t index =
static_cast<size_t>(e);
577 static const char *
const names[5] = {
589 const size_t index =
static_cast<size_t>(e);
609 static const char *
const names[3] = {
619 const size_t index =
static_cast<size_t>(e);
645 static const char *
const names[6] = {
658 const size_t index =
static_cast<size_t>(e);
683 bool VerifyConstTensorDataVector(flatbuffers::Verifier &verifier,
const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
const flatbuffers::Vector<uint8_t> *types);
825 static const char *
const names[65] = {
834 "DepthwiseConvolution2d",
849 "BatchNormalization",
859 "DetectionPostProcess",
868 "TransposeConvolution2d",
876 "InstanceNormalization",
889 "UnidirectionalSequenceLstm",
897 const size_t index =
static_cast<size_t>(e);
925 static const char *
const names[7] = {
939 const size_t index =
static_cast<size_t>(e);
971 static const char *
const names[9] = {
987 const size_t index =
static_cast<size_t>(e);
1007 static const char *
const names[3] = {
1017 const size_t index =
static_cast<size_t>(e);
1039 static const char *
const names[4] = {
1050 const size_t index =
static_cast<size_t>(e);
1070 static const char *
const names[3] = {
1080 const size_t index =
static_cast<size_t>(e);
1100 static const char *
const names[3] = {
1110 const size_t index =
static_cast<size_t>(e);
1130 static const char *
const names[3] = {
1140 const size_t index =
static_cast<size_t>(e);
1160 static const char *
const names[3] = {
1170 const size_t index =
static_cast<size_t>(e);
1245 static const Layer values[] = {
1316 static const char *
const names[66] = {
1320 "BatchToSpaceNdLayer",
1321 "BatchNormalizationLayer",
1323 "Convolution2dLayer",
1324 "DepthwiseConvolution2dLayer",
1325 "FullyConnectedLayer",
1327 "MultiplicationLayer",
1333 "SpaceToBatchNdLayer",
1338 "NormalizationLayer",
1343 "ResizeBilinearLayer",
1345 "StridedSliceLayer",
1349 "L2NormalizationLayer",
1351 "DetectionPostProcessLayer",
1353 "QuantizedLstmLayer",
1359 "SpaceToDepthLayer",
1361 "TransposeConvolution2dLayer",
1367 "DepthToSpaceLayer",
1368 "InstanceNormalizationLayer",
1372 "ElementwiseUnaryLayer",
1377 "LogicalBinaryLayer",
1381 "UnidirectionalSequenceLstmLayer",
1389 const size_t index =
static_cast<size_t>(e);
1653 bool VerifyLayer(flatbuffers::Verifier &verifier,
const void *obj,
Layer type);
1654 bool VerifyLayerVector(flatbuffers::Verifier &verifier,
const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
const flatbuffers::Vector<uint8_t> *types);
1658 uint32_t sourceLayerIndex_;
1659 uint32_t outputSlotIndex_;
1663 memset(static_cast<void *>(
this), 0,
sizeof(Connection));
1665 Connection(uint32_t _sourceLayerIndex, uint32_t _outputSlotIndex)
1666 : sourceLayerIndex_(flatbuffers::EndianScalar(_sourceLayerIndex)),
1667 outputSlotIndex_(flatbuffers::EndianScalar(_outputSlotIndex)) {
1669 uint32_t sourceLayerIndex()
const {
1670 return flatbuffers::EndianScalar(sourceLayerIndex_);
1672 uint32_t outputSlotIndex()
const {
1673 return flatbuffers::EndianScalar(outputSlotIndex_);
1680 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1692 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_DIMENSIONS);
1716 return GetField<uint8_t>(VT_ISCONSTANT, 0) != 0;
1718 bool Verify(flatbuffers::Verifier &verifier)
const {
1719 return VerifyTableStart(verifier) &&
1721 verifier.VerifyVector(dimensions()) &&
1726 verifier.VerifyVector(quantizationScales()) &&
1730 verifier.VerifyVector(dimensionSpecificity()) &&
1731 VerifyField<uint8_t>(verifier, VT_ISCONSTANT) &&
1732 verifier.EndTable();
1738 flatbuffers::FlatBufferBuilder &
fbb_;
1765 fbb_.AddElement<uint8_t>(TensorInfo::VT_ISCONSTANT,
static_cast<uint8_t
>(isConstant), 0);
1769 start_ = fbb_.StartTable();
1773 const auto end = fbb_.EndTable(start_);
1774 auto o = flatbuffers::Offset<TensorInfo>(end);
1780 flatbuffers::FlatBufferBuilder &_fbb,
1783 float quantizationScale = 1.0f,
1784 int32_t quantizationOffset = 0,
1786 uint32_t quantizationDim = 0,
1787 uint32_t dimensionality = 1,
1789 bool isConstant =
false) {
1800 return builder_.
Finish();
1804 flatbuffers::FlatBufferBuilder &_fbb,
1805 const std::vector<uint32_t> *dimensions =
nullptr,
1807 float quantizationScale = 1.0f,
1808 int32_t quantizationOffset = 0,
1809 const std::vector<float> *quantizationScales =
nullptr,
1810 uint32_t quantizationDim = 0,
1811 uint32_t dimensionality = 1,
1812 const std::vector<uint8_t> *dimensionSpecificity =
nullptr,
1813 bool isConstant =
false) {
1814 auto dimensions__ = dimensions ? _fbb.CreateVector<uint32_t>(*dimensions) : 0;
1815 auto quantizationScales__ = quantizationScales ? _fbb.CreateVector<
float>(*quantizationScales) : 0;
1816 auto dimensionSpecificity__ = dimensionSpecificity ? _fbb.CreateVector<uint8_t>(*dimensionSpecificity) : 0;
1823 quantizationScales__,
1826 dimensionSpecificity__,
1830 struct ByteData FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
1832 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1835 const flatbuffers::Vector<int8_t> *
data()
const {
1836 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_DATA);
1838 bool Verify(flatbuffers::Verifier &verifier)
const {
1839 return VerifyTableStart(verifier) &&
1840 VerifyOffset(verifier, VT_DATA) &&
1841 verifier.VerifyVector(data()) &&
1842 verifier.EndTable();
1848 flatbuffers::FlatBufferBuilder &
fbb_;
1851 fbb_.AddOffset(ByteData::VT_DATA, data);
1855 start_ = fbb_.StartTable();
1859 const auto end = fbb_.EndTable(start_);
1860 auto o = flatbuffers::Offset<ByteData>(end);
1866 flatbuffers::FlatBufferBuilder &_fbb,
1870 return builder_.
Finish();
1874 flatbuffers::FlatBufferBuilder &_fbb,
1875 const std::vector<int8_t> *data =
nullptr) {
1876 auto data__ = data ? _fbb.CreateVector<int8_t>(*data) : 0;
1882 struct ShortData FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
1884 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1887 const flatbuffers::Vector<int16_t> *
data()
const {
1888 return GetPointer<const flatbuffers::Vector<int16_t> *>(VT_DATA);
1890 bool Verify(flatbuffers::Verifier &verifier)
const {
1891 return VerifyTableStart(verifier) &&
1892 VerifyOffset(verifier, VT_DATA) &&
1893 verifier.VerifyVector(data()) &&
1894 verifier.EndTable();
1900 flatbuffers::FlatBufferBuilder &
fbb_;
1903 fbb_.AddOffset(ShortData::VT_DATA, data);
1907 start_ = fbb_.StartTable();
1911 const auto end = fbb_.EndTable(start_);
1912 auto o = flatbuffers::Offset<ShortData>(end);
1918 flatbuffers::FlatBufferBuilder &_fbb,
1922 return builder_.
Finish();
1926 flatbuffers::FlatBufferBuilder &_fbb,
1927 const std::vector<int16_t> *data =
nullptr) {
1928 auto data__ = data ? _fbb.CreateVector<int16_t>(*data) : 0;
1934 struct IntData FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
1936 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1939 const flatbuffers::Vector<int32_t> *
data()
const {
1940 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_DATA);
1942 bool Verify(flatbuffers::Verifier &verifier)
const {
1943 return VerifyTableStart(verifier) &&
1944 VerifyOffset(verifier, VT_DATA) &&
1945 verifier.VerifyVector(data()) &&
1946 verifier.EndTable();
1952 flatbuffers::FlatBufferBuilder &
fbb_;
1955 fbb_.AddOffset(IntData::VT_DATA, data);
1959 start_ = fbb_.StartTable();
1963 const auto end = fbb_.EndTable(start_);
1964 auto o = flatbuffers::Offset<IntData>(end);
1970 flatbuffers::FlatBufferBuilder &_fbb,
1974 return builder_.
Finish();
1978 flatbuffers::FlatBufferBuilder &_fbb,
1979 const std::vector<int32_t> *data =
nullptr) {
1980 auto data__ = data ? _fbb.CreateVector<int32_t>(*data) : 0;
1986 struct LongData FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
1988 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1991 const flatbuffers::Vector<int64_t> *
data()
const {
1992 return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_DATA);
1994 bool Verify(flatbuffers::Verifier &verifier)
const {
1995 return VerifyTableStart(verifier) &&
1996 VerifyOffset(verifier, VT_DATA) &&
1997 verifier.VerifyVector(data()) &&
1998 verifier.EndTable();
2004 flatbuffers::FlatBufferBuilder &
fbb_;
2007 fbb_.AddOffset(LongData::VT_DATA, data);
2011 start_ = fbb_.StartTable();
2015 const auto end = fbb_.EndTable(start_);
2016 auto o = flatbuffers::Offset<LongData>(end);
2022 flatbuffers::FlatBufferBuilder &_fbb,
2026 return builder_.
Finish();
2030 flatbuffers::FlatBufferBuilder &_fbb,
2031 const std::vector<int64_t> *data =
nullptr) {
2032 auto data__ = data ? _fbb.CreateVector<int64_t>(*data) : 0;
2038 struct ConstTensor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2040 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2045 const armnnSerializer::TensorInfo *
info()
const {
2046 return GetPointer<const armnnSerializer::TensorInfo *>(
VT_INFO);
2052 return GetPointer<const void *>(VT_DATA);
2054 template<
typename T>
const T *data_as()
const;
2067 bool Verify(flatbuffers::Verifier &verifier)
const {
2068 return VerifyTableStart(verifier) &&
2069 VerifyOffset(verifier,
VT_INFO) &&
2070 verifier.VerifyTable(info()) &&
2072 VerifyOffset(verifier, VT_DATA) &&
2074 verifier.EndTable();
2078 template<>
inline const armnnSerializer::ByteData *ConstTensor::data_as<armnnSerializer::ByteData>()
const {
2079 return data_as_ByteData();
2082 template<>
inline const armnnSerializer::ShortData *ConstTensor::data_as<armnnSerializer::ShortData>()
const {
2083 return data_as_ShortData();
2086 template<>
inline const armnnSerializer::IntData *ConstTensor::data_as<armnnSerializer::IntData>()
const {
2087 return data_as_IntData();
2090 template<>
inline const armnnSerializer::LongData *ConstTensor::data_as<armnnSerializer::LongData>()
const {
2091 return data_as_LongData();
2096 flatbuffers::FlatBufferBuilder &
fbb_;
2098 void add_info(flatbuffers::Offset<armnnSerializer::TensorInfo> info) {
2105 fbb_.AddOffset(ConstTensor::VT_DATA, data);
2109 start_ = fbb_.StartTable();
2113 const auto end = fbb_.EndTable(start_);
2114 auto o = flatbuffers::Offset<ConstTensor>(end);
2120 flatbuffers::FlatBufferBuilder &_fbb,
2121 flatbuffers::Offset<armnnSerializer::TensorInfo> info = 0,
2123 flatbuffers::Offset<void> data = 0) {
2128 return builder_.
Finish();
2131 struct InputSlot FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2133 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2138 return GetField<uint32_t>(
VT_INDEX, 0);
2141 return GetStruct<const armnnSerializer::Connection *>(VT_CONNECTION);
2143 bool Verify(flatbuffers::Verifier &verifier)
const {
2144 return VerifyTableStart(verifier) &&
2145 VerifyField<uint32_t>(verifier,
VT_INDEX) &&
2146 VerifyField<armnnSerializer::Connection>(verifier, VT_CONNECTION) &&
2147 verifier.EndTable();
2153 flatbuffers::FlatBufferBuilder &
fbb_;
2159 fbb_.AddStruct(InputSlot::VT_CONNECTION, connection);
2163 start_ = fbb_.StartTable();
2167 const auto end = fbb_.EndTable(start_);
2168 auto o = flatbuffers::Offset<InputSlot>(end);
2174 flatbuffers::FlatBufferBuilder &_fbb,
2176 const armnnSerializer::Connection *connection = 0) {
2180 return builder_.
Finish();
2183 struct OutputSlot FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2185 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2190 return GetField<uint32_t>(
VT_INDEX, 0);
2193 return GetPointer<const armnnSerializer::TensorInfo *>(VT_TENSORINFO);
2195 bool Verify(flatbuffers::Verifier &verifier)
const {
2196 return VerifyTableStart(verifier) &&
2197 VerifyField<uint32_t>(verifier,
VT_INDEX) &&
2198 VerifyOffset(verifier, VT_TENSORINFO) &&
2199 verifier.VerifyTable(tensorInfo()) &&
2200 verifier.EndTable();
2206 flatbuffers::FlatBufferBuilder &
fbb_;
2212 fbb_.AddOffset(OutputSlot::VT_TENSORINFO, tensorInfo);
2216 start_ = fbb_.StartTable();
2220 const auto end = fbb_.EndTable(start_);
2221 auto o = flatbuffers::Offset<OutputSlot>(end);
2227 flatbuffers::FlatBufferBuilder &_fbb,
2229 flatbuffers::Offset<armnnSerializer::TensorInfo> tensorInfo = 0) {
2233 return builder_.
Finish();
2236 struct LayerBase FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2238 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2246 return GetField<uint32_t>(
VT_INDEX, 0);
2249 return GetPointer<const flatbuffers::String *>(
VT_LAYERNAME);
2254 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::InputSlot>> *
inputSlots()
const {
2255 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::InputSlot>> *>(
VT_INPUTSLOTS);
2257 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::OutputSlot>> *
outputSlots()
const {
2258 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::OutputSlot>> *>(VT_OUTPUTSLOTS);
2260 bool Verify(flatbuffers::Verifier &verifier)
const {
2261 return VerifyTableStart(verifier) &&
2262 VerifyField<uint32_t>(verifier,
VT_INDEX) &&
2264 verifier.VerifyString(layerName()) &&
2267 verifier.VerifyVector(inputSlots()) &&
2268 verifier.VerifyVectorOfTables(inputSlots()) &&
2269 VerifyOffset(verifier, VT_OUTPUTSLOTS) &&
2270 verifier.VerifyVector(outputSlots()) &&
2271 verifier.VerifyVectorOfTables(outputSlots()) &&
2272 verifier.EndTable();
2278 flatbuffers::FlatBufferBuilder &
fbb_;
2293 fbb_.AddOffset(LayerBase::VT_OUTPUTSLOTS, outputSlots);
2297 start_ = fbb_.StartTable();
2301 const auto end = fbb_.EndTable(start_);
2302 auto o = flatbuffers::Offset<LayerBase>(end);
2308 flatbuffers::FlatBufferBuilder &_fbb,
2310 flatbuffers::Offset<flatbuffers::String> layerName = 0,
2312 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::InputSlot>>> inputSlots = 0,
2313 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::OutputSlot>>> outputSlots = 0) {
2320 return builder_.
Finish();
2324 flatbuffers::FlatBufferBuilder &_fbb,
2326 const char *layerName =
nullptr,
2328 const std::vector<flatbuffers::Offset<armnnSerializer::InputSlot>> *inputSlots =
nullptr,
2329 const std::vector<flatbuffers::Offset<armnnSerializer::OutputSlot>> *outputSlots =
nullptr) {
2330 auto layerName__ = layerName ? _fbb.CreateString(layerName) : 0;
2331 auto inputSlots__ = inputSlots ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::InputSlot>>(*inputSlots) : 0;
2332 auto outputSlots__ = outputSlots ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::OutputSlot>>(*outputSlots) : 0;
2342 struct BindableLayerBase FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2344 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2346 VT_LAYERBINDINGID = 6
2348 const armnnSerializer::LayerBase *
base()
const {
2349 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2352 return GetField<int32_t>(VT_LAYERBINDINGID, 0);
2354 bool Verify(flatbuffers::Verifier &verifier)
const {
2355 return VerifyTableStart(verifier) &&
2356 VerifyOffset(verifier,
VT_BASE) &&
2357 verifier.VerifyTable(base()) &&
2358 VerifyField<int32_t>(verifier, VT_LAYERBINDINGID) &&
2359 verifier.EndTable();
2365 flatbuffers::FlatBufferBuilder &
fbb_;
2367 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2371 fbb_.AddElement<int32_t>(BindableLayerBase::VT_LAYERBINDINGID, layerBindingId, 0);
2375 start_ = fbb_.StartTable();
2378 flatbuffers::Offset<BindableLayerBase>
Finish() {
2379 const auto end = fbb_.EndTable(start_);
2380 auto o = flatbuffers::Offset<BindableLayerBase>(end);
2386 flatbuffers::FlatBufferBuilder &_fbb,
2387 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2388 int32_t layerBindingId = 0) {
2392 return builder_.
Finish();
2396 struct AbsLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2398 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2401 const armnnSerializer::LayerBase *
base()
const {
2402 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2404 bool Verify(flatbuffers::Verifier &verifier)
const {
2405 return VerifyTableStart(verifier) &&
2406 VerifyOffset(verifier,
VT_BASE) &&
2407 verifier.VerifyTable(base()) &&
2408 verifier.EndTable();
2414 flatbuffers::FlatBufferBuilder &
fbb_;
2416 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2421 start_ = fbb_.StartTable();
2425 const auto end = fbb_.EndTable(start_);
2426 auto o = flatbuffers::Offset<AbsLayer>(end);
2432 flatbuffers::FlatBufferBuilder &_fbb,
2433 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
2436 return builder_.
Finish();
2439 struct ActivationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2441 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2445 const armnnSerializer::LayerBase *
base()
const {
2446 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2448 const armnnSerializer::ActivationDescriptor *
descriptor()
const {
2449 return GetPointer<const armnnSerializer::ActivationDescriptor *>(
VT_DESCRIPTOR);
2451 bool Verify(flatbuffers::Verifier &verifier)
const {
2452 return VerifyTableStart(verifier) &&
2453 VerifyOffset(verifier,
VT_BASE) &&
2454 verifier.VerifyTable(base()) &&
2456 verifier.VerifyTable(descriptor()) &&
2457 verifier.EndTable();
2463 flatbuffers::FlatBufferBuilder &
fbb_;
2465 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2468 void add_descriptor(flatbuffers::Offset<armnnSerializer::ActivationDescriptor> descriptor) {
2473 start_ = fbb_.StartTable();
2476 flatbuffers::Offset<ActivationLayer>
Finish() {
2477 const auto end = fbb_.EndTable(start_);
2478 auto o = flatbuffers::Offset<ActivationLayer>(end);
2484 flatbuffers::FlatBufferBuilder &_fbb,
2485 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2486 flatbuffers::Offset<armnnSerializer::ActivationDescriptor> descriptor = 0) {
2490 return builder_.
Finish();
2493 struct ActivationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2495 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2504 return GetField<float>(
VT_A, 0.0f);
2507 return GetField<float>(VT_B, 0.0f);
2509 bool Verify(flatbuffers::Verifier &verifier)
const {
2510 return VerifyTableStart(verifier) &&
2512 VerifyField<float>(verifier,
VT_A) &&
2513 VerifyField<float>(verifier, VT_B) &&
2514 verifier.EndTable();
2520 flatbuffers::FlatBufferBuilder &
fbb_;
2529 fbb_.AddElement<
float>(ActivationDescriptor::VT_B, b, 0.0f);
2533 start_ = fbb_.StartTable();
2536 flatbuffers::Offset<ActivationDescriptor>
Finish() {
2537 const auto end = fbb_.EndTable(start_);
2538 auto o = flatbuffers::Offset<ActivationDescriptor>(end);
2544 flatbuffers::FlatBufferBuilder &_fbb,
2552 return builder_.
Finish();
2555 struct AdditionLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2557 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2560 const armnnSerializer::LayerBase *
base()
const {
2561 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2563 bool Verify(flatbuffers::Verifier &verifier)
const {
2564 return VerifyTableStart(verifier) &&
2565 VerifyOffset(verifier,
VT_BASE) &&
2566 verifier.VerifyTable(base()) &&
2567 verifier.EndTable();
2573 flatbuffers::FlatBufferBuilder &
fbb_;
2575 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2580 start_ = fbb_.StartTable();
2583 flatbuffers::Offset<AdditionLayer>
Finish() {
2584 const auto end = fbb_.EndTable(start_);
2585 auto o = flatbuffers::Offset<AdditionLayer>(end);
2591 flatbuffers::FlatBufferBuilder &_fbb,
2592 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
2595 return builder_.
Finish();
2598 struct ArgMinMaxLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2600 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2604 const armnnSerializer::LayerBase *
base()
const {
2605 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2608 return GetPointer<const armnnSerializer::ArgMinMaxDescriptor *>(
VT_DESCRIPTOR);
2610 bool Verify(flatbuffers::Verifier &verifier)
const {
2611 return VerifyTableStart(verifier) &&
2612 VerifyOffset(verifier,
VT_BASE) &&
2613 verifier.VerifyTable(base()) &&
2615 verifier.VerifyTable(descriptor()) &&
2616 verifier.EndTable();
2622 flatbuffers::FlatBufferBuilder &
fbb_;
2624 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2627 void add_descriptor(flatbuffers::Offset<armnnSerializer::ArgMinMaxDescriptor> descriptor) {
2632 start_ = fbb_.StartTable();
2635 flatbuffers::Offset<ArgMinMaxLayer>
Finish() {
2636 const auto end = fbb_.EndTable(start_);
2637 auto o = flatbuffers::Offset<ArgMinMaxLayer>(end);
2643 flatbuffers::FlatBufferBuilder &_fbb,
2644 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2645 flatbuffers::Offset<armnnSerializer::ArgMinMaxDescriptor> descriptor = 0) {
2649 return builder_.
Finish();
2652 struct ArgMinMaxDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2654 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2662 return GetField<int32_t>(
VT_AXIS, 0);
2664 bool Verify(flatbuffers::Verifier &verifier)
const {
2665 return VerifyTableStart(verifier) &&
2667 VerifyField<int32_t>(verifier,
VT_AXIS) &&
2668 verifier.EndTable();
2674 flatbuffers::FlatBufferBuilder &
fbb_;
2684 start_ = fbb_.StartTable();
2687 flatbuffers::Offset<ArgMinMaxDescriptor>
Finish() {
2688 const auto end = fbb_.EndTable(start_);
2689 auto o = flatbuffers::Offset<ArgMinMaxDescriptor>(end);
2695 flatbuffers::FlatBufferBuilder &_fbb,
2701 return builder_.
Finish();
2704 struct CastLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2706 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2709 const armnnSerializer::LayerBase *
base()
const {
2710 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2712 bool Verify(flatbuffers::Verifier &verifier)
const {
2713 return VerifyTableStart(verifier) &&
2714 VerifyOffset(verifier,
VT_BASE) &&
2715 verifier.VerifyTable(base()) &&
2716 verifier.EndTable();
2722 flatbuffers::FlatBufferBuilder &
fbb_;
2724 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2729 start_ = fbb_.StartTable();
2733 const auto end = fbb_.EndTable(start_);
2734 auto o = flatbuffers::Offset<CastLayer>(end);
2740 flatbuffers::FlatBufferBuilder &_fbb,
2741 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
2744 return builder_.
Finish();
2747 struct ComparisonDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2749 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2755 bool Verify(flatbuffers::Verifier &verifier)
const {
2756 return VerifyTableStart(verifier) &&
2757 VerifyField<int8_t>(verifier, VT_OPERATION) &&
2758 verifier.EndTable();
2764 flatbuffers::FlatBufferBuilder &
fbb_;
2767 fbb_.AddElement<int8_t>(ComparisonDescriptor::VT_OPERATION,
static_cast<int8_t
>(operation), 0);
2771 start_ = fbb_.StartTable();
2774 flatbuffers::Offset<ComparisonDescriptor>
Finish() {
2775 const auto end = fbb_.EndTable(start_);
2776 auto o = flatbuffers::Offset<ComparisonDescriptor>(end);
2782 flatbuffers::FlatBufferBuilder &_fbb,
2786 return builder_.
Finish();
2789 struct ComparisonLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2791 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2795 const armnnSerializer::LayerBase *
base()
const {
2796 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2798 const armnnSerializer::ComparisonDescriptor *
descriptor()
const {
2799 return GetPointer<const armnnSerializer::ComparisonDescriptor *>(
VT_DESCRIPTOR);
2801 bool Verify(flatbuffers::Verifier &verifier)
const {
2802 return VerifyTableStart(verifier) &&
2803 VerifyOffset(verifier,
VT_BASE) &&
2804 verifier.VerifyTable(base()) &&
2806 verifier.VerifyTable(descriptor()) &&
2807 verifier.EndTable();
2813 flatbuffers::FlatBufferBuilder &
fbb_;
2815 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2818 void add_descriptor(flatbuffers::Offset<armnnSerializer::ComparisonDescriptor> descriptor) {
2823 start_ = fbb_.StartTable();
2826 flatbuffers::Offset<ComparisonLayer>
Finish() {
2827 const auto end = fbb_.EndTable(start_);
2828 auto o = flatbuffers::Offset<ComparisonLayer>(end);
2834 flatbuffers::FlatBufferBuilder &_fbb,
2835 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2836 flatbuffers::Offset<armnnSerializer::ComparisonDescriptor> descriptor = 0) {
2840 return builder_.
Finish();
2843 struct ConstantLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2845 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2849 const armnnSerializer::LayerBase *
base()
const {
2850 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2852 const armnnSerializer::ConstTensor *
input()
const {
2853 return GetPointer<const armnnSerializer::ConstTensor *>(VT_INPUT);
2855 bool Verify(flatbuffers::Verifier &verifier)
const {
2856 return VerifyTableStart(verifier) &&
2857 VerifyOffset(verifier,
VT_BASE) &&
2858 verifier.VerifyTable(base()) &&
2859 VerifyOffset(verifier, VT_INPUT) &&
2860 verifier.VerifyTable(input()) &&
2861 verifier.EndTable();
2867 flatbuffers::FlatBufferBuilder &
fbb_;
2869 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2872 void add_input(flatbuffers::Offset<armnnSerializer::ConstTensor> input) {
2873 fbb_.AddOffset(ConstantLayer::VT_INPUT, input);
2877 start_ = fbb_.StartTable();
2880 flatbuffers::Offset<ConstantLayer>
Finish() {
2881 const auto end = fbb_.EndTable(start_);
2882 auto o = flatbuffers::Offset<ConstantLayer>(end);
2888 flatbuffers::FlatBufferBuilder &_fbb,
2889 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2890 flatbuffers::Offset<armnnSerializer::ConstTensor> input = 0) {
2894 return builder_.
Finish();
2897 struct Convolution2dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2899 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2905 const armnnSerializer::LayerBase *
base()
const {
2906 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2908 const armnnSerializer::Convolution2dDescriptor *
descriptor()
const {
2909 return GetPointer<const armnnSerializer::Convolution2dDescriptor *>(
VT_DESCRIPTOR);
2911 const armnnSerializer::ConstTensor *
weights()
const {
2912 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_WEIGHTS);
2914 const armnnSerializer::ConstTensor *
biases()
const {
2915 return GetPointer<const armnnSerializer::ConstTensor *>(VT_BIASES);
2917 bool Verify(flatbuffers::Verifier &verifier)
const {
2918 return VerifyTableStart(verifier) &&
2919 VerifyOffset(verifier,
VT_BASE) &&
2920 verifier.VerifyTable(base()) &&
2922 verifier.VerifyTable(descriptor()) &&
2924 verifier.VerifyTable(weights()) &&
2925 VerifyOffset(verifier, VT_BIASES) &&
2926 verifier.VerifyTable(biases()) &&
2927 verifier.EndTable();
2933 flatbuffers::FlatBufferBuilder &
fbb_;
2935 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2938 void add_descriptor(flatbuffers::Offset<armnnSerializer::Convolution2dDescriptor> descriptor) {
2941 void add_weights(flatbuffers::Offset<armnnSerializer::ConstTensor> weights) {
2944 void add_biases(flatbuffers::Offset<armnnSerializer::ConstTensor> biases) {
2945 fbb_.AddOffset(Convolution2dLayer::VT_BIASES, biases);
2949 start_ = fbb_.StartTable();
2952 flatbuffers::Offset<Convolution2dLayer>
Finish() {
2953 const auto end = fbb_.EndTable(start_);
2954 auto o = flatbuffers::Offset<Convolution2dLayer>(end);
2960 flatbuffers::FlatBufferBuilder &_fbb,
2961 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2962 flatbuffers::Offset<armnnSerializer::Convolution2dDescriptor> descriptor = 0,
2963 flatbuffers::Offset<armnnSerializer::ConstTensor> weights = 0,
2964 flatbuffers::Offset<armnnSerializer::ConstTensor> biases = 0) {
2970 return builder_.
Finish();
2973 struct Convolution2dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2975 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2994 return GetField<uint32_t>(
VT_PADTOP, 0);
3017 bool Verify(flatbuffers::Verifier &verifier)
const {
3018 return VerifyTableStart(verifier) &&
3019 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
3021 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
3023 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
3024 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
3029 verifier.EndTable();
3035 flatbuffers::FlatBufferBuilder &
fbb_;
3069 start_ = fbb_.StartTable();
3072 flatbuffers::Offset<Convolution2dDescriptor>
Finish() {
3073 const auto end = fbb_.EndTable(start_);
3074 auto o = flatbuffers::Offset<Convolution2dDescriptor>(end);
3080 flatbuffers::FlatBufferBuilder &_fbb,
3081 uint32_t padLeft = 0,
3082 uint32_t padRight = 0,
3083 uint32_t padTop = 0,
3084 uint32_t padBottom = 0,
3085 uint32_t strideX = 0,
3086 uint32_t strideY = 0,
3087 uint32_t dilationX = 1,
3088 uint32_t dilationY = 1,
3089 bool biasEnabled =
false,
3102 return builder_.
Finish();
3105 struct DepthToSpaceLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3107 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3111 const armnnSerializer::LayerBase *
base()
const {
3112 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3115 return GetPointer<const armnnSerializer::DepthToSpaceDescriptor *>(
VT_DESCRIPTOR);
3117 bool Verify(flatbuffers::Verifier &verifier)
const {
3118 return VerifyTableStart(verifier) &&
3119 VerifyOffset(verifier,
VT_BASE) &&
3120 verifier.VerifyTable(base()) &&
3122 verifier.VerifyTable(descriptor()) &&
3123 verifier.EndTable();
3129 flatbuffers::FlatBufferBuilder &
fbb_;
3131 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3134 void add_descriptor(flatbuffers::Offset<armnnSerializer::DepthToSpaceDescriptor> descriptor) {
3139 start_ = fbb_.StartTable();
3142 flatbuffers::Offset<DepthToSpaceLayer>
Finish() {
3143 const auto end = fbb_.EndTable(start_);
3144 auto o = flatbuffers::Offset<DepthToSpaceLayer>(end);
3150 flatbuffers::FlatBufferBuilder &_fbb,
3151 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3152 flatbuffers::Offset<armnnSerializer::DepthToSpaceDescriptor> descriptor = 0) {
3156 return builder_.
Finish();
3161 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3171 bool Verify(flatbuffers::Verifier &verifier)
const {
3172 return VerifyTableStart(verifier) &&
3175 verifier.EndTable();
3181 flatbuffers::FlatBufferBuilder &
fbb_;
3191 start_ = fbb_.StartTable();
3194 flatbuffers::Offset<DepthToSpaceDescriptor>
Finish() {
3195 const auto end = fbb_.EndTable(start_);
3196 auto o = flatbuffers::Offset<DepthToSpaceDescriptor>(end);
3202 flatbuffers::FlatBufferBuilder &_fbb,
3203 uint32_t blockSize = 0,
3208 return builder_.
Finish();
3211 struct DivisionLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3213 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3216 const armnnSerializer::LayerBase *
base()
const {
3217 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3219 bool Verify(flatbuffers::Verifier &verifier)
const {
3220 return VerifyTableStart(verifier) &&
3221 VerifyOffset(verifier,
VT_BASE) &&
3222 verifier.VerifyTable(base()) &&
3223 verifier.EndTable();
3229 flatbuffers::FlatBufferBuilder &
fbb_;
3231 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3236 start_ = fbb_.StartTable();
3239 flatbuffers::Offset<DivisionLayer>
Finish() {
3240 const auto end = fbb_.EndTable(start_);
3241 auto o = flatbuffers::Offset<DivisionLayer>(end);
3247 flatbuffers::FlatBufferBuilder &_fbb,
3248 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
3251 return builder_.
Finish();
3254 struct ElementwiseUnaryDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3256 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3262 bool Verify(flatbuffers::Verifier &verifier)
const {
3263 return VerifyTableStart(verifier) &&
3264 VerifyField<int8_t>(verifier, VT_OPERATION) &&
3265 verifier.EndTable();
3270 typedef ElementwiseUnaryDescriptor
Table;
3271 flatbuffers::FlatBufferBuilder &
fbb_;
3274 fbb_.AddElement<int8_t>(ElementwiseUnaryDescriptor::VT_OPERATION,
static_cast<int8_t
>(operation), 0);
3278 start_ = fbb_.StartTable();
3281 flatbuffers::Offset<ElementwiseUnaryDescriptor>
Finish() {
3282 const auto end = fbb_.EndTable(start_);
3283 auto o = flatbuffers::Offset<ElementwiseUnaryDescriptor>(end);
3289 flatbuffers::FlatBufferBuilder &_fbb,
3293 return builder_.
Finish();
3296 struct ElementwiseUnaryLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3298 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3302 const armnnSerializer::LayerBase *
base()
const {
3303 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3305 const armnnSerializer::ElementwiseUnaryDescriptor *
descriptor()
const {
3306 return GetPointer<const armnnSerializer::ElementwiseUnaryDescriptor *>(
VT_DESCRIPTOR);
3308 bool Verify(flatbuffers::Verifier &verifier)
const {
3309 return VerifyTableStart(verifier) &&
3310 VerifyOffset(verifier,
VT_BASE) &&
3311 verifier.VerifyTable(base()) &&
3313 verifier.VerifyTable(descriptor()) &&
3314 verifier.EndTable();
3320 flatbuffers::FlatBufferBuilder &
fbb_;
3322 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3325 void add_descriptor(flatbuffers::Offset<armnnSerializer::ElementwiseUnaryDescriptor> descriptor) {
3330 start_ = fbb_.StartTable();
3333 flatbuffers::Offset<ElementwiseUnaryLayer>
Finish() {
3334 const auto end = fbb_.EndTable(start_);
3335 auto o = flatbuffers::Offset<ElementwiseUnaryLayer>(end);
3341 flatbuffers::FlatBufferBuilder &_fbb,
3342 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3343 flatbuffers::Offset<armnnSerializer::ElementwiseUnaryDescriptor> descriptor = 0) {
3347 return builder_.
Finish();
3351 struct EqualLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3353 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3356 const armnnSerializer::LayerBase *
base()
const {
3357 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3359 bool Verify(flatbuffers::Verifier &verifier)
const {
3360 return VerifyTableStart(verifier) &&
3361 VerifyOffset(verifier,
VT_BASE) &&
3362 verifier.VerifyTable(base()) &&
3363 verifier.EndTable();
3369 flatbuffers::FlatBufferBuilder &
fbb_;
3371 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3376 start_ = fbb_.StartTable();
3380 const auto end = fbb_.EndTable(start_);
3381 auto o = flatbuffers::Offset<EqualLayer>(end);
3387 flatbuffers::FlatBufferBuilder &_fbb,
3388 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
3391 return builder_.
Finish();
3394 struct FillLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3396 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3400 const armnnSerializer::LayerBase *
base()
const {
3401 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3404 return GetPointer<const armnnSerializer::FillDescriptor *>(
VT_DESCRIPTOR);
3406 bool Verify(flatbuffers::Verifier &verifier)
const {
3407 return VerifyTableStart(verifier) &&
3408 VerifyOffset(verifier,
VT_BASE) &&
3409 verifier.VerifyTable(base()) &&
3411 verifier.VerifyTable(descriptor()) &&
3412 verifier.EndTable();
3418 flatbuffers::FlatBufferBuilder &
fbb_;
3420 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3423 void add_descriptor(flatbuffers::Offset<armnnSerializer::FillDescriptor> descriptor) {
3428 start_ = fbb_.StartTable();
3432 const auto end = fbb_.EndTable(start_);
3433 auto o = flatbuffers::Offset<FillLayer>(end);
3439 flatbuffers::FlatBufferBuilder &_fbb,
3440 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3441 flatbuffers::Offset<armnnSerializer::FillDescriptor> descriptor = 0) {
3445 return builder_.
Finish();
3448 struct FillDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3450 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3454 return GetField<float>(VT_VALUE, 0.0f);
3456 bool Verify(flatbuffers::Verifier &verifier)
const {
3457 return VerifyTableStart(verifier) &&
3458 VerifyField<float>(verifier, VT_VALUE) &&
3459 verifier.EndTable();
3465 flatbuffers::FlatBufferBuilder &
fbb_;
3468 fbb_.AddElement<
float>(FillDescriptor::VT_VALUE, value, 0.0f);
3472 start_ = fbb_.StartTable();
3475 flatbuffers::Offset<FillDescriptor>
Finish() {
3476 const auto end = fbb_.EndTable(start_);
3477 auto o = flatbuffers::Offset<FillDescriptor>(end);
3483 flatbuffers::FlatBufferBuilder &_fbb,
3484 float value = 0.0f) {
3487 return builder_.
Finish();
3490 struct FloorLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3492 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3495 const armnnSerializer::LayerBase *
base()
const {
3496 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3498 bool Verify(flatbuffers::Verifier &verifier)
const {
3499 return VerifyTableStart(verifier) &&
3500 VerifyOffset(verifier,
VT_BASE) &&
3501 verifier.VerifyTable(base()) &&
3502 verifier.EndTable();
3508 flatbuffers::FlatBufferBuilder &
fbb_;
3510 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3515 start_ = fbb_.StartTable();
3519 const auto end = fbb_.EndTable(start_);
3520 auto o = flatbuffers::Offset<FloorLayer>(end);
3526 flatbuffers::FlatBufferBuilder &_fbb,
3527 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
3530 return builder_.
Finish();
3533 struct FullyConnectedLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3535 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3541 const armnnSerializer::LayerBase *
base()
const {
3542 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3544 const armnnSerializer::FullyConnectedDescriptor *
descriptor()
const {
3545 return GetPointer<const armnnSerializer::FullyConnectedDescriptor *>(
VT_DESCRIPTOR);
3547 const armnnSerializer::ConstTensor *
weights()
const {
3548 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_WEIGHTS);
3550 const armnnSerializer::ConstTensor *
biases()
const {
3551 return GetPointer<const armnnSerializer::ConstTensor *>(VT_BIASES);
3553 bool Verify(flatbuffers::Verifier &verifier)
const {
3554 return VerifyTableStart(verifier) &&
3555 VerifyOffset(verifier,
VT_BASE) &&
3556 verifier.VerifyTable(base()) &&
3558 verifier.VerifyTable(descriptor()) &&
3560 verifier.VerifyTable(weights()) &&
3561 VerifyOffset(verifier, VT_BIASES) &&
3562 verifier.VerifyTable(biases()) &&
3563 verifier.EndTable();
3569 flatbuffers::FlatBufferBuilder &
fbb_;
3571 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3574 void add_descriptor(flatbuffers::Offset<armnnSerializer::FullyConnectedDescriptor> descriptor) {
3577 void add_weights(flatbuffers::Offset<armnnSerializer::ConstTensor> weights) {
3580 void add_biases(flatbuffers::Offset<armnnSerializer::ConstTensor> biases) {
3581 fbb_.AddOffset(FullyConnectedLayer::VT_BIASES, biases);
3585 start_ = fbb_.StartTable();
3588 flatbuffers::Offset<FullyConnectedLayer>
Finish() {
3589 const auto end = fbb_.EndTable(start_);
3590 auto o = flatbuffers::Offset<FullyConnectedLayer>(end);
3596 flatbuffers::FlatBufferBuilder &_fbb,
3597 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3598 flatbuffers::Offset<armnnSerializer::FullyConnectedDescriptor> descriptor = 0,
3599 flatbuffers::Offset<armnnSerializer::ConstTensor> weights = 0,
3600 flatbuffers::Offset<armnnSerializer::ConstTensor> biases = 0) {
3606 return builder_.
Finish();
3609 struct FullyConnectedDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3611 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3614 VT_CONSTANTWEIGHTS = 8
3623 return GetField<uint8_t>(VT_CONSTANTWEIGHTS, 1) != 0;
3625 bool Verify(flatbuffers::Verifier &verifier)
const {
3626 return VerifyTableStart(verifier) &&
3629 VerifyField<uint8_t>(verifier, VT_CONSTANTWEIGHTS) &&
3630 verifier.EndTable();
3636 flatbuffers::FlatBufferBuilder &
fbb_;
3645 fbb_.AddElement<uint8_t>(FullyConnectedDescriptor::VT_CONSTANTWEIGHTS,
static_cast<uint8_t
>(constantWeights), 1);
3649 start_ = fbb_.StartTable();
3652 flatbuffers::Offset<FullyConnectedDescriptor>
Finish() {
3653 const auto end = fbb_.EndTable(start_);
3654 auto o = flatbuffers::Offset<FullyConnectedDescriptor>(end);
3660 flatbuffers::FlatBufferBuilder &_fbb,
3661 bool biasEnabled =
false,
3662 bool transposeWeightsMatrix =
false,
3663 bool constantWeights =
true) {
3668 return builder_.
Finish();
3671 struct GatherLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3673 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3677 const armnnSerializer::LayerBase *
base()
const {
3678 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3681 return GetPointer<const armnnSerializer::GatherDescriptor *>(
VT_DESCRIPTOR);
3683 bool Verify(flatbuffers::Verifier &verifier)
const {
3684 return VerifyTableStart(verifier) &&
3685 VerifyOffset(verifier,
VT_BASE) &&
3686 verifier.VerifyTable(base()) &&
3688 verifier.VerifyTable(descriptor()) &&
3689 verifier.EndTable();
3695 flatbuffers::FlatBufferBuilder &
fbb_;
3697 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3700 void add_descriptor(flatbuffers::Offset<armnnSerializer::GatherDescriptor> descriptor) {
3705 start_ = fbb_.StartTable();
3709 const auto end = fbb_.EndTable(start_);
3710 auto o = flatbuffers::Offset<GatherLayer>(end);
3716 flatbuffers::FlatBufferBuilder &_fbb,
3717 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3718 flatbuffers::Offset<armnnSerializer::GatherDescriptor> descriptor = 0) {
3722 return builder_.
Finish();
3725 struct GatherDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3727 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3731 return GetField<int32_t>(
VT_AXIS, 0);
3733 bool Verify(flatbuffers::Verifier &verifier)
const {
3734 return VerifyTableStart(verifier) &&
3735 VerifyField<int32_t>(verifier,
VT_AXIS) &&
3736 verifier.EndTable();
3742 flatbuffers::FlatBufferBuilder &
fbb_;
3749 start_ = fbb_.StartTable();
3752 flatbuffers::Offset<GatherDescriptor>
Finish() {
3753 const auto end = fbb_.EndTable(start_);
3754 auto o = flatbuffers::Offset<GatherDescriptor>(end);
3760 flatbuffers::FlatBufferBuilder &_fbb,
3764 return builder_.
Finish();
3768 struct GreaterLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3770 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3773 const armnnSerializer::LayerBase *
base()
const {
3774 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3776 bool Verify(flatbuffers::Verifier &verifier)
const {
3777 return VerifyTableStart(verifier) &&
3778 VerifyOffset(verifier,
VT_BASE) &&
3779 verifier.VerifyTable(base()) &&
3780 verifier.EndTable();
3786 flatbuffers::FlatBufferBuilder &
fbb_;
3788 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3793 start_ = fbb_.StartTable();
3797 const auto end = fbb_.EndTable(start_);
3798 auto o = flatbuffers::Offset<GreaterLayer>(end);
3804 flatbuffers::FlatBufferBuilder &_fbb,
3805 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
3808 return builder_.
Finish();
3811 struct InputLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3813 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3816 const armnnSerializer::BindableLayerBase *
base()
const {
3817 return GetPointer<const armnnSerializer::BindableLayerBase *>(
VT_BASE);
3819 bool Verify(flatbuffers::Verifier &verifier)
const {
3820 return VerifyTableStart(verifier) &&
3821 VerifyOffset(verifier,
VT_BASE) &&
3822 verifier.VerifyTable(base()) &&
3823 verifier.EndTable();
3829 flatbuffers::FlatBufferBuilder &
fbb_;
3831 void add_base(flatbuffers::Offset<armnnSerializer::BindableLayerBase> base) {
3836 start_ = fbb_.StartTable();
3840 const auto end = fbb_.EndTable(start_);
3841 auto o = flatbuffers::Offset<InputLayer>(end);
3847 flatbuffers::FlatBufferBuilder &_fbb,
3848 flatbuffers::Offset<armnnSerializer::BindableLayerBase> base = 0) {
3851 return builder_.
Finish();
3854 struct InstanceNormalizationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3856 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3860 const armnnSerializer::LayerBase *
base()
const {
3861 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3863 const armnnSerializer::InstanceNormalizationDescriptor *
descriptor()
const {
3864 return GetPointer<const armnnSerializer::InstanceNormalizationDescriptor *>(
VT_DESCRIPTOR);
3866 bool Verify(flatbuffers::Verifier &verifier)
const {
3867 return VerifyTableStart(verifier) &&
3868 VerifyOffset(verifier,
VT_BASE) &&
3869 verifier.VerifyTable(base()) &&
3871 verifier.VerifyTable(descriptor()) &&
3872 verifier.EndTable();
3877 typedef InstanceNormalizationLayer
Table;
3878 flatbuffers::FlatBufferBuilder &
fbb_;
3880 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3883 void add_descriptor(flatbuffers::Offset<armnnSerializer::InstanceNormalizationDescriptor> descriptor) {
3888 start_ = fbb_.StartTable();
3891 flatbuffers::Offset<InstanceNormalizationLayer>
Finish() {
3892 const auto end = fbb_.EndTable(start_);
3893 auto o = flatbuffers::Offset<InstanceNormalizationLayer>(end);
3899 flatbuffers::FlatBufferBuilder &_fbb,
3900 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3901 flatbuffers::Offset<armnnSerializer::InstanceNormalizationDescriptor> descriptor = 0) {
3905 return builder_.
Finish();
3908 struct InstanceNormalizationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3910 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3917 return GetField<float>(
VT_GAMMA, 0.0f);
3920 return GetField<float>(
VT_BETA, 0.0f);
3923 return GetField<float>(
VT_EPS, 0.0f);
3928 bool Verify(flatbuffers::Verifier &verifier)
const {
3929 return VerifyTableStart(verifier) &&
3930 VerifyField<float>(verifier,
VT_GAMMA) &&
3931 VerifyField<float>(verifier,
VT_BETA) &&
3932 VerifyField<float>(verifier,
VT_EPS) &&
3934 verifier.EndTable();
3939 typedef InstanceNormalizationDescriptor
Table;
3940 flatbuffers::FlatBufferBuilder &
fbb_;
3956 start_ = fbb_.StartTable();
3959 flatbuffers::Offset<InstanceNormalizationDescriptor>
Finish() {
3960 const auto end = fbb_.EndTable(start_);
3961 auto o = flatbuffers::Offset<InstanceNormalizationDescriptor>(end);
3967 flatbuffers::FlatBufferBuilder &_fbb,
3977 return builder_.
Finish();
3980 struct LogSoftmaxLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3982 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3986 const armnnSerializer::LayerBase *
base()
const {
3987 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3990 return GetPointer<const armnnSerializer::LogSoftmaxDescriptor *>(
VT_DESCRIPTOR);
3992 bool Verify(flatbuffers::Verifier &verifier)
const {
3993 return VerifyTableStart(verifier) &&
3994 VerifyOffset(verifier,
VT_BASE) &&
3995 verifier.VerifyTable(base()) &&
3997 verifier.VerifyTable(descriptor()) &&
3998 verifier.EndTable();
4004 flatbuffers::FlatBufferBuilder &
fbb_;
4006 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4009 void add_descriptor(flatbuffers::Offset<armnnSerializer::LogSoftmaxDescriptor> descriptor) {
4014 start_ = fbb_.StartTable();
4017 flatbuffers::Offset<LogSoftmaxLayer>
Finish() {
4018 const auto end = fbb_.EndTable(start_);
4019 auto o = flatbuffers::Offset<LogSoftmaxLayer>(end);
4025 flatbuffers::FlatBufferBuilder &_fbb,
4026 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4027 flatbuffers::Offset<armnnSerializer::LogSoftmaxDescriptor> descriptor = 0) {
4031 return builder_.
Finish();
4036 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4041 return GetField<float>(
VT_BETA, 1.0f);
4044 return GetField<int32_t>(
VT_AXIS, -1);
4046 bool Verify(flatbuffers::Verifier &verifier)
const {
4047 return VerifyTableStart(verifier) &&
4048 VerifyField<float>(verifier,
VT_BETA) &&
4049 VerifyField<int32_t>(verifier,
VT_AXIS) &&
4050 verifier.EndTable();
4056 flatbuffers::FlatBufferBuilder &
fbb_;
4066 start_ = fbb_.StartTable();
4069 flatbuffers::Offset<LogSoftmaxDescriptor>
Finish() {
4070 const auto end = fbb_.EndTable(start_);
4071 auto o = flatbuffers::Offset<LogSoftmaxDescriptor>(end);
4077 flatbuffers::FlatBufferBuilder &_fbb,
4079 int32_t axis = -1) {
4083 return builder_.
Finish();
4086 struct L2NormalizationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4088 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4092 const armnnSerializer::LayerBase *
base()
const {
4093 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4095 const armnnSerializer::L2NormalizationDescriptor *
descriptor()
const {
4096 return GetPointer<const armnnSerializer::L2NormalizationDescriptor *>(
VT_DESCRIPTOR);
4098 bool Verify(flatbuffers::Verifier &verifier)
const {
4099 return VerifyTableStart(verifier) &&
4100 VerifyOffset(verifier,
VT_BASE) &&
4101 verifier.VerifyTable(base()) &&
4103 verifier.VerifyTable(descriptor()) &&
4104 verifier.EndTable();
4110 flatbuffers::FlatBufferBuilder &
fbb_;
4112 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4115 void add_descriptor(flatbuffers::Offset<armnnSerializer::L2NormalizationDescriptor> descriptor) {
4120 start_ = fbb_.StartTable();
4123 flatbuffers::Offset<L2NormalizationLayer>
Finish() {
4124 const auto end = fbb_.EndTable(start_);
4125 auto o = flatbuffers::Offset<L2NormalizationLayer>(end);
4131 flatbuffers::FlatBufferBuilder &_fbb,
4132 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4133 flatbuffers::Offset<armnnSerializer::L2NormalizationDescriptor> descriptor = 0) {
4137 return builder_.
Finish();
4140 struct L2NormalizationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4142 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4150 return GetField<float>(
VT_EPS, 1e-12f);
4152 bool Verify(flatbuffers::Verifier &verifier)
const {
4153 return VerifyTableStart(verifier) &&
4155 VerifyField<float>(verifier,
VT_EPS) &&
4156 verifier.EndTable();
4161 typedef L2NormalizationDescriptor
Table;
4162 flatbuffers::FlatBufferBuilder &
fbb_;
4172 start_ = fbb_.StartTable();
4175 flatbuffers::Offset<L2NormalizationDescriptor>
Finish() {
4176 const auto end = fbb_.EndTable(start_);
4177 auto o = flatbuffers::Offset<L2NormalizationDescriptor>(end);
4183 flatbuffers::FlatBufferBuilder &_fbb,
4185 float eps = 1e-12f) {
4189 return builder_.
Finish();
4192 struct LogicalBinaryDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4194 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4200 bool Verify(flatbuffers::Verifier &verifier)
const {
4201 return VerifyTableStart(verifier) &&
4202 VerifyField<int8_t>(verifier, VT_OPERATION) &&
4203 verifier.EndTable();
4209 flatbuffers::FlatBufferBuilder &
fbb_;
4212 fbb_.AddElement<int8_t>(LogicalBinaryDescriptor::VT_OPERATION,
static_cast<int8_t
>(operation), 0);
4216 start_ = fbb_.StartTable();
4219 flatbuffers::Offset<LogicalBinaryDescriptor>
Finish() {
4220 const auto end = fbb_.EndTable(start_);
4221 auto o = flatbuffers::Offset<LogicalBinaryDescriptor>(end);
4227 flatbuffers::FlatBufferBuilder &_fbb,
4231 return builder_.
Finish();
4234 struct LogicalBinaryLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4236 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4240 const armnnSerializer::LayerBase *
base()
const {
4241 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4243 const armnnSerializer::LogicalBinaryDescriptor *
descriptor()
const {
4244 return GetPointer<const armnnSerializer::LogicalBinaryDescriptor *>(
VT_DESCRIPTOR);
4246 bool Verify(flatbuffers::Verifier &verifier)
const {
4247 return VerifyTableStart(verifier) &&
4248 VerifyOffset(verifier,
VT_BASE) &&
4249 verifier.VerifyTable(base()) &&
4251 verifier.VerifyTable(descriptor()) &&
4252 verifier.EndTable();
4258 flatbuffers::FlatBufferBuilder &
fbb_;
4260 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4263 void add_descriptor(flatbuffers::Offset<armnnSerializer::LogicalBinaryDescriptor> descriptor) {
4268 start_ = fbb_.StartTable();
4271 flatbuffers::Offset<LogicalBinaryLayer>
Finish() {
4272 const auto end = fbb_.EndTable(start_);
4273 auto o = flatbuffers::Offset<LogicalBinaryLayer>(end);
4279 flatbuffers::FlatBufferBuilder &_fbb,
4280 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4281 flatbuffers::Offset<armnnSerializer::LogicalBinaryDescriptor> descriptor = 0) {
4285 return builder_.
Finish();
4288 struct MinimumLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4290 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4293 const armnnSerializer::LayerBase *
base()
const {
4294 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4296 bool Verify(flatbuffers::Verifier &verifier)
const {
4297 return VerifyTableStart(verifier) &&
4298 VerifyOffset(verifier,
VT_BASE) &&
4299 verifier.VerifyTable(base()) &&
4300 verifier.EndTable();
4306 flatbuffers::FlatBufferBuilder &
fbb_;
4308 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4313 start_ = fbb_.StartTable();
4317 const auto end = fbb_.EndTable(start_);
4318 auto o = flatbuffers::Offset<MinimumLayer>(end);
4324 flatbuffers::FlatBufferBuilder &_fbb,
4325 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4328 return builder_.
Finish();
4331 struct MaximumLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4333 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4336 const armnnSerializer::LayerBase *
base()
const {
4337 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4339 bool Verify(flatbuffers::Verifier &verifier)
const {
4340 return VerifyTableStart(verifier) &&
4341 VerifyOffset(verifier,
VT_BASE) &&
4342 verifier.VerifyTable(base()) &&
4343 verifier.EndTable();
4349 flatbuffers::FlatBufferBuilder &
fbb_;
4351 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4356 start_ = fbb_.StartTable();
4360 const auto end = fbb_.EndTable(start_);
4361 auto o = flatbuffers::Offset<MaximumLayer>(end);
4367 flatbuffers::FlatBufferBuilder &_fbb,
4368 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4371 return builder_.
Finish();
4374 struct MultiplicationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4376 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4379 const armnnSerializer::LayerBase *
base()
const {
4380 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4382 bool Verify(flatbuffers::Verifier &verifier)
const {
4383 return VerifyTableStart(verifier) &&
4384 VerifyOffset(verifier,
VT_BASE) &&
4385 verifier.VerifyTable(base()) &&
4386 verifier.EndTable();
4392 flatbuffers::FlatBufferBuilder &
fbb_;
4394 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4399 start_ = fbb_.StartTable();
4402 flatbuffers::Offset<MultiplicationLayer>
Finish() {
4403 const auto end = fbb_.EndTable(start_);
4404 auto o = flatbuffers::Offset<MultiplicationLayer>(end);
4410 flatbuffers::FlatBufferBuilder &_fbb,
4411 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4414 return builder_.
Finish();
4417 struct Pooling2dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4419 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4423 const armnnSerializer::LayerBase *
base()
const {
4424 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4427 return GetPointer<const armnnSerializer::Pooling2dDescriptor *>(
VT_DESCRIPTOR);
4429 bool Verify(flatbuffers::Verifier &verifier)
const {
4430 return VerifyTableStart(verifier) &&
4431 VerifyOffset(verifier,
VT_BASE) &&
4432 verifier.VerifyTable(base()) &&
4434 verifier.VerifyTable(descriptor()) &&
4435 verifier.EndTable();
4441 flatbuffers::FlatBufferBuilder &
fbb_;
4443 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4446 void add_descriptor(flatbuffers::Offset<armnnSerializer::Pooling2dDescriptor> descriptor) {
4451 start_ = fbb_.StartTable();
4454 flatbuffers::Offset<Pooling2dLayer>
Finish() {
4455 const auto end = fbb_.EndTable(start_);
4456 auto o = flatbuffers::Offset<Pooling2dLayer>(end);
4462 flatbuffers::FlatBufferBuilder &_fbb,
4463 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4464 flatbuffers::Offset<armnnSerializer::Pooling2dDescriptor> descriptor = 0) {
4468 return builder_.
Finish();
4471 struct Pooling2dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4473 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4497 return GetField<uint32_t>(
VT_PADTOP, 0);
4523 bool Verify(flatbuffers::Verifier &verifier)
const {
4524 return VerifyTableStart(verifier) &&
4526 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
4528 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
4532 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
4533 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
4537 verifier.EndTable();
4543 flatbuffers::FlatBufferBuilder &
fbb_;
4583 start_ = fbb_.StartTable();
4586 flatbuffers::Offset<Pooling2dDescriptor>
Finish() {
4587 const auto end = fbb_.EndTable(start_);
4588 auto o = flatbuffers::Offset<Pooling2dDescriptor>(end);
4594 flatbuffers::FlatBufferBuilder &_fbb,
4596 uint32_t padLeft = 0,
4597 uint32_t padRight = 0,
4598 uint32_t padTop = 0,
4599 uint32_t padBottom = 0,
4600 uint32_t poolWidth = 0,
4601 uint32_t poolHeight = 0,
4602 uint32_t strideX = 0,
4603 uint32_t strideY = 0,
4620 return builder_.
Finish();
4623 struct QuantizeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4625 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4628 const armnnSerializer::LayerBase *
base()
const {
4629 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4631 bool Verify(flatbuffers::Verifier &verifier)
const {
4632 return VerifyTableStart(verifier) &&
4633 VerifyOffset(verifier,
VT_BASE) &&
4634 verifier.VerifyTable(base()) &&
4635 verifier.EndTable();
4641 flatbuffers::FlatBufferBuilder &
fbb_;
4643 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4648 start_ = fbb_.StartTable();
4651 flatbuffers::Offset<QuantizeLayer>
Finish() {
4652 const auto end = fbb_.EndTable(start_);
4653 auto o = flatbuffers::Offset<QuantizeLayer>(end);
4659 flatbuffers::FlatBufferBuilder &_fbb,
4660 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4663 return builder_.
Finish();
4666 struct SoftmaxLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4668 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4672 const armnnSerializer::LayerBase *
base()
const {
4673 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4676 return GetPointer<const armnnSerializer::SoftmaxDescriptor *>(
VT_DESCRIPTOR);
4678 bool Verify(flatbuffers::Verifier &verifier)
const {
4679 return VerifyTableStart(verifier) &&
4680 VerifyOffset(verifier,
VT_BASE) &&
4681 verifier.VerifyTable(base()) &&
4683 verifier.VerifyTable(descriptor()) &&
4684 verifier.EndTable();
4690 flatbuffers::FlatBufferBuilder &
fbb_;
4692 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4695 void add_descriptor(flatbuffers::Offset<armnnSerializer::SoftmaxDescriptor> descriptor) {
4700 start_ = fbb_.StartTable();
4704 const auto end = fbb_.EndTable(start_);
4705 auto o = flatbuffers::Offset<SoftmaxLayer>(end);
4711 flatbuffers::FlatBufferBuilder &_fbb,
4712 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4713 flatbuffers::Offset<armnnSerializer::SoftmaxDescriptor> descriptor = 0) {
4717 return builder_.
Finish();
4720 struct SoftmaxDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4722 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4726 return GetField<float>(
VT_BETA, 0.0f);
4728 bool Verify(flatbuffers::Verifier &verifier)
const {
4729 return VerifyTableStart(verifier) &&
4730 VerifyField<float>(verifier,
VT_BETA) &&
4731 verifier.EndTable();
4737 flatbuffers::FlatBufferBuilder &
fbb_;
4744 start_ = fbb_.StartTable();
4747 flatbuffers::Offset<SoftmaxDescriptor>
Finish() {
4748 const auto end = fbb_.EndTable(start_);
4749 auto o = flatbuffers::Offset<SoftmaxDescriptor>(end);
4755 flatbuffers::FlatBufferBuilder &_fbb,
4756 float beta = 0.0f) {
4759 return builder_.
Finish();
4762 struct DepthwiseConvolution2dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4764 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4770 const armnnSerializer::LayerBase *
base()
const {
4771 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4773 const armnnSerializer::DepthwiseConvolution2dDescriptor *
descriptor()
const {
4774 return GetPointer<const armnnSerializer::DepthwiseConvolution2dDescriptor *>(
VT_DESCRIPTOR);
4776 const armnnSerializer::ConstTensor *
weights()
const {
4777 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_WEIGHTS);
4779 const armnnSerializer::ConstTensor *
biases()
const {
4780 return GetPointer<const armnnSerializer::ConstTensor *>(VT_BIASES);
4782 bool Verify(flatbuffers::Verifier &verifier)
const {
4783 return VerifyTableStart(verifier) &&
4784 VerifyOffset(verifier,
VT_BASE) &&
4785 verifier.VerifyTable(base()) &&
4787 verifier.VerifyTable(descriptor()) &&
4789 verifier.VerifyTable(weights()) &&
4790 VerifyOffset(verifier, VT_BIASES) &&
4791 verifier.VerifyTable(biases()) &&
4792 verifier.EndTable();
4797 typedef DepthwiseConvolution2dLayer
Table;
4798 flatbuffers::FlatBufferBuilder &
fbb_;
4800 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4803 void add_descriptor(flatbuffers::Offset<armnnSerializer::DepthwiseConvolution2dDescriptor> descriptor) {
4806 void add_weights(flatbuffers::Offset<armnnSerializer::ConstTensor> weights) {
4809 void add_biases(flatbuffers::Offset<armnnSerializer::ConstTensor> biases) {
4810 fbb_.AddOffset(DepthwiseConvolution2dLayer::VT_BIASES, biases);
4814 start_ = fbb_.StartTable();
4817 flatbuffers::Offset<DepthwiseConvolution2dLayer>
Finish() {
4818 const auto end = fbb_.EndTable(start_);
4819 auto o = flatbuffers::Offset<DepthwiseConvolution2dLayer>(end);
4825 flatbuffers::FlatBufferBuilder &_fbb,
4826 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4827 flatbuffers::Offset<armnnSerializer::DepthwiseConvolution2dDescriptor> descriptor = 0,
4828 flatbuffers::Offset<armnnSerializer::ConstTensor> weights = 0,
4829 flatbuffers::Offset<armnnSerializer::ConstTensor> biases = 0) {
4835 return builder_.
Finish();
4838 struct DepthwiseConvolution2dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4840 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4859 return GetField<uint32_t>(
VT_PADTOP, 0);
4882 bool Verify(flatbuffers::Verifier &verifier)
const {
4883 return VerifyTableStart(verifier) &&
4884 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
4886 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
4888 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
4889 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
4894 verifier.EndTable();
4899 typedef DepthwiseConvolution2dDescriptor
Table;
4900 flatbuffers::FlatBufferBuilder &
fbb_;
4934 start_ = fbb_.StartTable();
4937 flatbuffers::Offset<DepthwiseConvolution2dDescriptor>
Finish() {
4938 const auto end = fbb_.EndTable(start_);
4939 auto o = flatbuffers::Offset<DepthwiseConvolution2dDescriptor>(end);
4945 flatbuffers::FlatBufferBuilder &_fbb,
4946 uint32_t padLeft = 0,
4947 uint32_t padRight = 0,
4948 uint32_t padTop = 0,
4949 uint32_t padBottom = 0,
4950 uint32_t strideX = 0,
4951 uint32_t strideY = 0,
4952 uint32_t dilationX = 1,
4953 uint32_t dilationY = 1,
4954 bool biasEnabled =
false,
4967 return builder_.
Finish();
4970 struct OutputLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4972 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4975 const armnnSerializer::BindableLayerBase *
base()
const {
4976 return GetPointer<const armnnSerializer::BindableLayerBase *>(
VT_BASE);
4978 bool Verify(flatbuffers::Verifier &verifier)
const {
4979 return VerifyTableStart(verifier) &&
4980 VerifyOffset(verifier,
VT_BASE) &&
4981 verifier.VerifyTable(base()) &&
4982 verifier.EndTable();
4988 flatbuffers::FlatBufferBuilder &
fbb_;
4990 void add_base(flatbuffers::Offset<armnnSerializer::BindableLayerBase> base) {
4995 start_ = fbb_.StartTable();
4999 const auto end = fbb_.EndTable(start_);
5000 auto o = flatbuffers::Offset<OutputLayer>(end);
5006 flatbuffers::FlatBufferBuilder &_fbb,
5007 flatbuffers::Offset<armnnSerializer::BindableLayerBase> base = 0) {
5010 return builder_.
Finish();
5013 struct ReshapeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5015 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5019 const armnnSerializer::LayerBase *
base()
const {
5020 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5023 return GetPointer<const armnnSerializer::ReshapeDescriptor *>(
VT_DESCRIPTOR);
5025 bool Verify(flatbuffers::Verifier &verifier)
const {
5026 return VerifyTableStart(verifier) &&
5027 VerifyOffset(verifier,
VT_BASE) &&
5028 verifier.VerifyTable(base()) &&
5030 verifier.VerifyTable(descriptor()) &&
5031 verifier.EndTable();
5037 flatbuffers::FlatBufferBuilder &
fbb_;
5039 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5042 void add_descriptor(flatbuffers::Offset<armnnSerializer::ReshapeDescriptor> descriptor) {
5047 start_ = fbb_.StartTable();
5051 const auto end = fbb_.EndTable(start_);
5052 auto o = flatbuffers::Offset<ReshapeLayer>(end);
5058 flatbuffers::FlatBufferBuilder &_fbb,
5059 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5060 flatbuffers::Offset<armnnSerializer::ReshapeDescriptor> descriptor = 0) {
5064 return builder_.
Finish();
5067 struct ReshapeDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5069 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5073 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_TARGETSHAPE);
5075 bool Verify(flatbuffers::Verifier &verifier)
const {
5076 return VerifyTableStart(verifier) &&
5077 VerifyOffset(verifier, VT_TARGETSHAPE) &&
5078 verifier.VerifyVector(targetShape()) &&
5079 verifier.EndTable();
5085 flatbuffers::FlatBufferBuilder &
fbb_;
5088 fbb_.AddOffset(ReshapeDescriptor::VT_TARGETSHAPE, targetShape);
5092 start_ = fbb_.StartTable();
5095 flatbuffers::Offset<ReshapeDescriptor>
Finish() {
5096 const auto end = fbb_.EndTable(start_);
5097 auto o = flatbuffers::Offset<ReshapeDescriptor>(end);
5103 flatbuffers::FlatBufferBuilder &_fbb,
5107 return builder_.
Finish();
5111 flatbuffers::FlatBufferBuilder &_fbb,
5112 const std::vector<uint32_t> *targetShape =
nullptr) {
5113 auto targetShape__ = targetShape ? _fbb.CreateVector<uint32_t>(*targetShape) : 0;
5119 struct PermuteLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5121 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5125 const armnnSerializer::LayerBase *
base()
const {
5126 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5129 return GetPointer<const armnnSerializer::PermuteDescriptor *>(
VT_DESCRIPTOR);
5131 bool Verify(flatbuffers::Verifier &verifier)
const {
5132 return VerifyTableStart(verifier) &&
5133 VerifyOffset(verifier,
VT_BASE) &&
5134 verifier.VerifyTable(base()) &&
5136 verifier.VerifyTable(descriptor()) &&
5137 verifier.EndTable();
5143 flatbuffers::FlatBufferBuilder &
fbb_;
5145 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5148 void add_descriptor(flatbuffers::Offset<armnnSerializer::PermuteDescriptor> descriptor) {
5153 start_ = fbb_.StartTable();
5157 const auto end = fbb_.EndTable(start_);
5158 auto o = flatbuffers::Offset<PermuteLayer>(end);
5164 flatbuffers::FlatBufferBuilder &_fbb,
5165 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5166 flatbuffers::Offset<armnnSerializer::PermuteDescriptor> descriptor = 0) {
5170 return builder_.
Finish();
5173 struct PermuteDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5175 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5179 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DIMMAPPINGS);
5181 bool Verify(flatbuffers::Verifier &verifier)
const {
5182 return VerifyTableStart(verifier) &&
5183 VerifyOffset(verifier, VT_DIMMAPPINGS) &&
5184 verifier.VerifyVector(dimMappings()) &&
5185 verifier.EndTable();
5191 flatbuffers::FlatBufferBuilder &
fbb_;
5194 fbb_.AddOffset(PermuteDescriptor::VT_DIMMAPPINGS, dimMappings);
5198 start_ = fbb_.StartTable();
5201 flatbuffers::Offset<PermuteDescriptor>
Finish() {
5202 const auto end = fbb_.EndTable(start_);
5203 auto o = flatbuffers::Offset<PermuteDescriptor>(end);
5209 flatbuffers::FlatBufferBuilder &_fbb,
5213 return builder_.
Finish();
5217 flatbuffers::FlatBufferBuilder &_fbb,
5218 const std::vector<uint32_t> *dimMappings =
nullptr) {
5219 auto dimMappings__ = dimMappings ? _fbb.CreateVector<uint32_t>(*dimMappings) : 0;
5225 struct ShapeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5227 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5230 const armnnSerializer::LayerBase *
base()
const {
5231 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5233 bool Verify(flatbuffers::Verifier &verifier)
const {
5234 return VerifyTableStart(verifier) &&
5235 VerifyOffset(verifier,
VT_BASE) &&
5236 verifier.VerifyTable(base()) &&
5237 verifier.EndTable();
5243 flatbuffers::FlatBufferBuilder &
fbb_;
5245 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5250 start_ = fbb_.StartTable();
5254 const auto end = fbb_.EndTable(start_);
5255 auto o = flatbuffers::Offset<ShapeLayer>(end);
5261 flatbuffers::FlatBufferBuilder &_fbb,
5262 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
5265 return builder_.
Finish();
5268 struct SpaceToBatchNdLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5270 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5274 const armnnSerializer::LayerBase *
base()
const {
5275 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5277 const armnnSerializer::SpaceToBatchNdDescriptor *
descriptor()
const {
5278 return GetPointer<const armnnSerializer::SpaceToBatchNdDescriptor *>(
VT_DESCRIPTOR);
5280 bool Verify(flatbuffers::Verifier &verifier)
const {
5281 return VerifyTableStart(verifier) &&
5282 VerifyOffset(verifier,
VT_BASE) &&
5283 verifier.VerifyTable(base()) &&
5285 verifier.VerifyTable(descriptor()) &&
5286 verifier.EndTable();
5292 flatbuffers::FlatBufferBuilder &
fbb_;
5294 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5297 void add_descriptor(flatbuffers::Offset<armnnSerializer::SpaceToBatchNdDescriptor> descriptor) {
5302 start_ = fbb_.StartTable();
5305 flatbuffers::Offset<SpaceToBatchNdLayer>
Finish() {
5306 const auto end = fbb_.EndTable(start_);
5307 auto o = flatbuffers::Offset<SpaceToBatchNdLayer>(end);
5313 flatbuffers::FlatBufferBuilder &_fbb,
5314 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5315 flatbuffers::Offset<armnnSerializer::SpaceToBatchNdDescriptor> descriptor = 0) {
5319 return builder_.
Finish();
5322 struct SpaceToBatchNdDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5324 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5330 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_BLOCKSHAPE);
5332 const flatbuffers::Vector<uint32_t> *
padList()
const {
5333 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_PADLIST);
5338 bool Verify(flatbuffers::Verifier &verifier)
const {
5339 return VerifyTableStart(verifier) &&
5341 verifier.VerifyVector(blockShape()) &&
5343 verifier.VerifyVector(padList()) &&
5345 verifier.EndTable();
5351 flatbuffers::FlatBufferBuilder &
fbb_;
5364 start_ = fbb_.StartTable();
5367 flatbuffers::Offset<SpaceToBatchNdDescriptor>
Finish() {
5368 const auto end = fbb_.EndTable(start_);
5369 auto o = flatbuffers::Offset<SpaceToBatchNdDescriptor>(end);
5375 flatbuffers::FlatBufferBuilder &_fbb,
5383 return builder_.
Finish();
5387 flatbuffers::FlatBufferBuilder &_fbb,
5388 const std::vector<uint32_t> *blockShape =
nullptr,
5389 const std::vector<uint32_t> *padList =
nullptr,
5391 auto blockShape__ = blockShape ? _fbb.CreateVector<uint32_t>(*blockShape) : 0;
5392 auto padList__ = padList ? _fbb.CreateVector<uint32_t>(*padList) : 0;
5400 struct SpaceToDepthLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5402 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5406 const armnnSerializer::LayerBase *
base()
const {
5407 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5409 const armnnSerializer::SpaceToDepthDescriptor *
descriptor()
const {
5410 return GetPointer<const armnnSerializer::SpaceToDepthDescriptor *>(
VT_DESCRIPTOR);
5412 bool Verify(flatbuffers::Verifier &verifier)
const {
5413 return VerifyTableStart(verifier) &&
5414 VerifyOffset(verifier,
VT_BASE) &&
5415 verifier.VerifyTable(base()) &&
5417 verifier.VerifyTable(descriptor()) &&
5418 verifier.EndTable();
5424 flatbuffers::FlatBufferBuilder &
fbb_;
5426 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5429 void add_descriptor(flatbuffers::Offset<armnnSerializer::SpaceToDepthDescriptor> descriptor) {
5434 start_ = fbb_.StartTable();
5437 flatbuffers::Offset<SpaceToDepthLayer>
Finish() {
5438 const auto end = fbb_.EndTable(start_);
5439 auto o = flatbuffers::Offset<SpaceToDepthLayer>(end);
5445 flatbuffers::FlatBufferBuilder &_fbb,
5446 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5447 flatbuffers::Offset<armnnSerializer::SpaceToDepthDescriptor> descriptor = 0) {
5451 return builder_.
Finish();
5454 struct SpaceToDepthDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5456 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5466 bool Verify(flatbuffers::Verifier &verifier)
const {
5467 return VerifyTableStart(verifier) &&
5470 verifier.EndTable();
5476 flatbuffers::FlatBufferBuilder &
fbb_;
5486 start_ = fbb_.StartTable();
5489 flatbuffers::Offset<SpaceToDepthDescriptor>
Finish() {
5490 const auto end = fbb_.EndTable(start_);
5491 auto o = flatbuffers::Offset<SpaceToDepthDescriptor>(end);
5497 flatbuffers::FlatBufferBuilder &_fbb,
5498 uint32_t blockSize = 0,
5503 return builder_.
Finish();
5506 struct SubtractionLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5508 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5511 const armnnSerializer::LayerBase *
base()
const {
5512 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5514 bool Verify(flatbuffers::Verifier &verifier)
const {
5515 return VerifyTableStart(verifier) &&
5516 VerifyOffset(verifier,
VT_BASE) &&
5517 verifier.VerifyTable(base()) &&
5518 verifier.EndTable();
5524 flatbuffers::FlatBufferBuilder &
fbb_;
5526 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5531 start_ = fbb_.StartTable();
5534 flatbuffers::Offset<SubtractionLayer>
Finish() {
5535 const auto end = fbb_.EndTable(start_);
5536 auto o = flatbuffers::Offset<SubtractionLayer>(end);
5542 flatbuffers::FlatBufferBuilder &_fbb,
5543 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
5546 return builder_.
Finish();
5549 struct BatchToSpaceNdLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5551 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5555 const armnnSerializer::LayerBase *
base()
const {
5556 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5558 const armnnSerializer::BatchToSpaceNdDescriptor *
descriptor()
const {
5559 return GetPointer<const armnnSerializer::BatchToSpaceNdDescriptor *>(
VT_DESCRIPTOR);
5561 bool Verify(flatbuffers::Verifier &verifier)
const {
5562 return VerifyTableStart(verifier) &&
5563 VerifyOffset(verifier,
VT_BASE) &&
5564 verifier.VerifyTable(base()) &&
5566 verifier.VerifyTable(descriptor()) &&
5567 verifier.EndTable();
5573 flatbuffers::FlatBufferBuilder &
fbb_;
5575 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5578 void add_descriptor(flatbuffers::Offset<armnnSerializer::BatchToSpaceNdDescriptor> descriptor) {
5583 start_ = fbb_.StartTable();
5586 flatbuffers::Offset<BatchToSpaceNdLayer>
Finish() {
5587 const auto end = fbb_.EndTable(start_);
5588 auto o = flatbuffers::Offset<BatchToSpaceNdLayer>(end);
5594 flatbuffers::FlatBufferBuilder &_fbb,
5595 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5596 flatbuffers::Offset<armnnSerializer::BatchToSpaceNdDescriptor> descriptor = 0) {
5600 return builder_.
Finish();
5603 struct BatchToSpaceNdDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5605 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5611 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_BLOCKSHAPE);
5613 const flatbuffers::Vector<uint32_t> *
crops()
const {
5614 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_CROPS);
5619 bool Verify(flatbuffers::Verifier &verifier)
const {
5620 return VerifyTableStart(verifier) &&
5622 verifier.VerifyVector(blockShape()) &&
5623 VerifyOffset(verifier,
VT_CROPS) &&
5624 verifier.VerifyVector(crops()) &&
5626 verifier.EndTable();
5632 flatbuffers::FlatBufferBuilder &
fbb_;
5645 start_ = fbb_.StartTable();
5648 flatbuffers::Offset<BatchToSpaceNdDescriptor>
Finish() {
5649 const auto end = fbb_.EndTable(start_);
5650 auto o = flatbuffers::Offset<BatchToSpaceNdDescriptor>(end);
5656 flatbuffers::FlatBufferBuilder &_fbb,
5664 return builder_.
Finish();
5668 flatbuffers::FlatBufferBuilder &_fbb,
5669 const std::vector<uint32_t> *blockShape =
nullptr,
5670 const std::vector<uint32_t> *crops =
nullptr,
5672 auto blockShape__ = blockShape ? _fbb.CreateVector<uint32_t>(*blockShape) : 0;
5673 auto crops__ = crops ? _fbb.CreateVector<uint32_t>(*crops) : 0;
5681 struct NormalizationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5683 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5687 const armnnSerializer::LayerBase *
base()
const {
5688 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5690 const armnnSerializer::NormalizationDescriptor *
descriptor()
const {
5691 return GetPointer<const armnnSerializer::NormalizationDescriptor *>(
VT_DESCRIPTOR);
5693 bool Verify(flatbuffers::Verifier &verifier)
const {
5694 return VerifyTableStart(verifier) &&
5695 VerifyOffset(verifier,
VT_BASE) &&
5696 verifier.VerifyTable(base()) &&
5698 verifier.VerifyTable(descriptor()) &&
5699 verifier.EndTable();
5705 flatbuffers::FlatBufferBuilder &
fbb_;
5707 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5710 void add_descriptor(flatbuffers::Offset<armnnSerializer::NormalizationDescriptor> descriptor) {
5715 start_ = fbb_.StartTable();
5718 flatbuffers::Offset<NormalizationLayer>
Finish() {
5719 const auto end = fbb_.EndTable(start_);
5720 auto o = flatbuffers::Offset<NormalizationLayer>(end);
5726 flatbuffers::FlatBufferBuilder &_fbb,
5727 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5728 flatbuffers::Offset<armnnSerializer::NormalizationDescriptor> descriptor = 0) {
5732 return builder_.
Finish();
5735 struct NormalizationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5737 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5756 return GetField<float>(
VT_ALPHA, 0.0f);
5759 return GetField<float>(
VT_BETA, 0.0f);
5762 return GetField<float>(
VT_K, 0.0f);
5767 bool Verify(flatbuffers::Verifier &verifier)
const {
5768 return VerifyTableStart(verifier) &&
5772 VerifyField<float>(verifier,
VT_ALPHA) &&
5773 VerifyField<float>(verifier,
VT_BETA) &&
5774 VerifyField<float>(verifier,
VT_K) &&
5776 verifier.EndTable();
5782 flatbuffers::FlatBufferBuilder &
fbb_;
5807 start_ = fbb_.StartTable();
5810 flatbuffers::Offset<NormalizationDescriptor>
Finish() {
5811 const auto end = fbb_.EndTable(start_);
5812 auto o = flatbuffers::Offset<NormalizationDescriptor>(end);
5818 flatbuffers::FlatBufferBuilder &_fbb,
5821 uint32_t normSize = 0,
5834 return builder_.
Finish();
5837 struct MeanLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5839 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5843 const armnnSerializer::LayerBase *
base()
const {
5844 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5847 return GetPointer<const armnnSerializer::MeanDescriptor *>(
VT_DESCRIPTOR);
5849 bool Verify(flatbuffers::Verifier &verifier)
const {
5850 return VerifyTableStart(verifier) &&
5851 VerifyOffset(verifier,
VT_BASE) &&
5852 verifier.VerifyTable(base()) &&
5854 verifier.VerifyTable(descriptor()) &&
5855 verifier.EndTable();
5861 flatbuffers::FlatBufferBuilder &
fbb_;
5863 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5866 void add_descriptor(flatbuffers::Offset<armnnSerializer::MeanDescriptor> descriptor) {
5871 start_ = fbb_.StartTable();
5875 const auto end = fbb_.EndTable(start_);
5876 auto o = flatbuffers::Offset<MeanLayer>(end);
5882 flatbuffers::FlatBufferBuilder &_fbb,
5883 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5884 flatbuffers::Offset<armnnSerializer::MeanDescriptor> descriptor = 0) {
5888 return builder_.
Finish();
5891 struct MeanDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5893 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5897 const flatbuffers::Vector<uint32_t> *
axis()
const {
5898 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_AXIS);
5903 bool Verify(flatbuffers::Verifier &verifier)
const {
5904 return VerifyTableStart(verifier) &&
5905 VerifyOffset(verifier,
VT_AXIS) &&
5906 verifier.VerifyVector(axis()) &&
5908 verifier.EndTable();
5914 flatbuffers::FlatBufferBuilder &
fbb_;
5924 start_ = fbb_.StartTable();
5927 flatbuffers::Offset<MeanDescriptor>
Finish() {
5928 const auto end = fbb_.EndTable(start_);
5929 auto o = flatbuffers::Offset<MeanDescriptor>(end);
5935 flatbuffers::FlatBufferBuilder &_fbb,
5937 bool keepDims =
false) {
5941 return builder_.
Finish();
5945 flatbuffers::FlatBufferBuilder &_fbb,
5946 const std::vector<uint32_t> *axis =
nullptr,
5947 bool keepDims =
false) {
5948 auto axis__ = axis ? _fbb.CreateVector<uint32_t>(*axis) : 0;
5955 struct PadLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5957 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5961 const armnnSerializer::LayerBase *
base()
const {
5962 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5965 return GetPointer<const armnnSerializer::PadDescriptor *>(
VT_DESCRIPTOR);
5967 bool Verify(flatbuffers::Verifier &verifier)
const {
5968 return VerifyTableStart(verifier) &&
5969 VerifyOffset(verifier,
VT_BASE) &&
5970 verifier.VerifyTable(base()) &&
5972 verifier.VerifyTable(descriptor()) &&
5973 verifier.EndTable();
5979 flatbuffers::FlatBufferBuilder &
fbb_;
5981 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5984 void add_descriptor(flatbuffers::Offset<armnnSerializer::PadDescriptor> descriptor) {
5989 start_ = fbb_.StartTable();
5993 const auto end = fbb_.EndTable(start_);
5994 auto o = flatbuffers::Offset<PadLayer>(end);
6000 flatbuffers::FlatBufferBuilder &_fbb,
6001 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6002 flatbuffers::Offset<armnnSerializer::PadDescriptor> descriptor = 0) {
6006 return builder_.
Finish();
6009 struct PadDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6011 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6015 const flatbuffers::Vector<uint32_t> *
padList()
const {
6016 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_PADLIST);
6019 return GetField<float>(VT_PADVALUE, 0.0f);
6021 bool Verify(flatbuffers::Verifier &verifier)
const {
6022 return VerifyTableStart(verifier) &&
6024 verifier.VerifyVector(padList()) &&
6025 VerifyField<float>(verifier, VT_PADVALUE) &&
6026 verifier.EndTable();
6032 flatbuffers::FlatBufferBuilder &
fbb_;
6038 fbb_.AddElement<
float>(PadDescriptor::VT_PADVALUE, padValue, 0.0f);
6042 start_ = fbb_.StartTable();
6045 flatbuffers::Offset<PadDescriptor>
Finish() {
6046 const auto end = fbb_.EndTable(start_);
6047 auto o = flatbuffers::Offset<PadDescriptor>(end);
6053 flatbuffers::FlatBufferBuilder &_fbb,
6055 float padValue = 0.0f) {
6059 return builder_.
Finish();
6063 flatbuffers::FlatBufferBuilder &_fbb,
6064 const std::vector<uint32_t> *padList =
nullptr,
6065 float padValue = 0.0f) {
6066 auto padList__ = padList ? _fbb.CreateVector<uint32_t>(*padList) : 0;
6074 struct RsqrtLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6076 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6079 const armnnSerializer::LayerBase *
base()
const {
6080 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6082 bool Verify(flatbuffers::Verifier &verifier)
const {
6083 return VerifyTableStart(verifier) &&
6084 VerifyOffset(verifier,
VT_BASE) &&
6085 verifier.VerifyTable(base()) &&
6086 verifier.EndTable();
6092 flatbuffers::FlatBufferBuilder &
fbb_;
6094 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6099 start_ = fbb_.StartTable();
6103 const auto end = fbb_.EndTable(start_);
6104 auto o = flatbuffers::Offset<RsqrtLayer>(end);
6110 flatbuffers::FlatBufferBuilder &_fbb,
6111 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
6114 return builder_.
Finish();
6117 struct BatchNormalizationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6119 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6127 const armnnSerializer::LayerBase *
base()
const {
6128 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6130 const armnnSerializer::BatchNormalizationDescriptor *
descriptor()
const {
6131 return GetPointer<const armnnSerializer::BatchNormalizationDescriptor *>(
VT_DESCRIPTOR);
6133 const armnnSerializer::ConstTensor *
mean()
const {
6134 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_MEAN);
6137 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_VARIANCE);
6139 const armnnSerializer::ConstTensor *
beta()
const {
6140 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_BETA);
6142 const armnnSerializer::ConstTensor *
gamma()
const {
6143 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_GAMMA);
6145 bool Verify(flatbuffers::Verifier &verifier)
const {
6146 return VerifyTableStart(verifier) &&
6147 VerifyOffset(verifier,
VT_BASE) &&
6148 verifier.VerifyTable(base()) &&
6150 verifier.VerifyTable(descriptor()) &&
6151 VerifyOffset(verifier,
VT_MEAN) &&
6152 verifier.VerifyTable(mean()) &&
6154 verifier.VerifyTable(variance()) &&
6155 VerifyOffset(verifier,
VT_BETA) &&
6156 verifier.VerifyTable(beta()) &&
6157 VerifyOffset(verifier,
VT_GAMMA) &&
6158 verifier.VerifyTable(gamma()) &&
6159 verifier.EndTable();
6165 flatbuffers::FlatBufferBuilder &
fbb_;
6167 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6170 void add_descriptor(flatbuffers::Offset<armnnSerializer::BatchNormalizationDescriptor> descriptor) {
6173 void add_mean(flatbuffers::Offset<armnnSerializer::ConstTensor> mean) {
6176 void add_variance(flatbuffers::Offset<armnnSerializer::ConstTensor> variance) {
6179 void add_beta(flatbuffers::Offset<armnnSerializer::ConstTensor> beta) {
6182 void add_gamma(flatbuffers::Offset<armnnSerializer::ConstTensor> gamma) {
6187 start_ = fbb_.StartTable();
6190 flatbuffers::Offset<BatchNormalizationLayer>
Finish() {
6191 const auto end = fbb_.EndTable(start_);
6192 auto o = flatbuffers::Offset<BatchNormalizationLayer>(end);
6198 flatbuffers::FlatBufferBuilder &_fbb,
6199 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6200 flatbuffers::Offset<armnnSerializer::BatchNormalizationDescriptor> descriptor = 0,
6201 flatbuffers::Offset<armnnSerializer::ConstTensor> mean = 0,
6202 flatbuffers::Offset<armnnSerializer::ConstTensor> variance = 0,
6203 flatbuffers::Offset<armnnSerializer::ConstTensor> beta = 0,
6204 flatbuffers::Offset<armnnSerializer::ConstTensor> gamma = 0) {
6212 return builder_.
Finish();
6215 struct BatchNormalizationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6217 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6222 return GetField<float>(
VT_EPS, 0.0f);
6227 bool Verify(flatbuffers::Verifier &verifier)
const {
6228 return VerifyTableStart(verifier) &&
6229 VerifyField<float>(verifier,
VT_EPS) &&
6231 verifier.EndTable();
6236 typedef BatchNormalizationDescriptor
Table;
6237 flatbuffers::FlatBufferBuilder &
fbb_;
6247 start_ = fbb_.StartTable();
6250 flatbuffers::Offset<BatchNormalizationDescriptor>
Finish() {
6251 const auto end = fbb_.EndTable(start_);
6252 auto o = flatbuffers::Offset<BatchNormalizationDescriptor>(end);
6258 flatbuffers::FlatBufferBuilder &_fbb,
6264 return builder_.
Finish();
6268 struct ResizeBilinearLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6270 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6274 const armnnSerializer::LayerBase *
base()
const {
6275 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6277 const armnnSerializer::ResizeBilinearDescriptor *
descriptor()
const {
6278 return GetPointer<const armnnSerializer::ResizeBilinearDescriptor *>(
VT_DESCRIPTOR);
6280 bool Verify(flatbuffers::Verifier &verifier)
const {
6281 return VerifyTableStart(verifier) &&
6282 VerifyOffset(verifier,
VT_BASE) &&
6283 verifier.VerifyTable(base()) &&
6285 verifier.VerifyTable(descriptor()) &&
6286 verifier.EndTable();
6292 flatbuffers::FlatBufferBuilder &
fbb_;
6294 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6297 void add_descriptor(flatbuffers::Offset<armnnSerializer::ResizeBilinearDescriptor> descriptor) {
6302 start_ = fbb_.StartTable();
6305 flatbuffers::Offset<ResizeBilinearLayer>
Finish() {
6306 const auto end = fbb_.EndTable(start_);
6307 auto o = flatbuffers::Offset<ResizeBilinearLayer>(end);
6313 flatbuffers::FlatBufferBuilder &_fbb,
6314 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6315 flatbuffers::Offset<armnnSerializer::ResizeBilinearDescriptor> descriptor = 0) {
6319 return builder_.
Finish();
6322 struct ResizeBilinearDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6324 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6329 VT_HALFPIXELCENTERS = 12
6344 return GetField<uint8_t>(VT_HALFPIXELCENTERS, 0) != 0;
6346 bool Verify(flatbuffers::Verifier &verifier)
const {
6347 return VerifyTableStart(verifier) &&
6352 VerifyField<uint8_t>(verifier, VT_HALFPIXELCENTERS) &&
6353 verifier.EndTable();
6359 flatbuffers::FlatBufferBuilder &
fbb_;
6374 fbb_.AddElement<uint8_t>(ResizeBilinearDescriptor::VT_HALFPIXELCENTERS,
static_cast<uint8_t
>(halfPixelCenters), 0);
6378 start_ = fbb_.StartTable();
6381 flatbuffers::Offset<ResizeBilinearDescriptor>
Finish() {
6382 const auto end = fbb_.EndTable(start_);
6383 auto o = flatbuffers::Offset<ResizeBilinearDescriptor>(end);
6389 flatbuffers::FlatBufferBuilder &_fbb,
6390 uint32_t targetWidth = 0,
6391 uint32_t targetHeight = 0,
6393 bool alignCorners =
false,
6394 bool halfPixelCenters =
false) {
6401 return builder_.
Finish();
6404 struct SliceLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6406 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6410 const armnnSerializer::LayerBase *
base()
const {
6411 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6414 return GetPointer<const armnnSerializer::SliceDescriptor *>(
VT_DESCRIPTOR);
6416 bool Verify(flatbuffers::Verifier &verifier)
const {
6417 return VerifyTableStart(verifier) &&
6418 VerifyOffset(verifier,
VT_BASE) &&
6419 verifier.VerifyTable(base()) &&
6421 verifier.VerifyTable(descriptor()) &&
6422 verifier.EndTable();
6428 flatbuffers::FlatBufferBuilder &
fbb_;
6430 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6433 void add_descriptor(flatbuffers::Offset<armnnSerializer::SliceDescriptor> descriptor) {
6438 start_ = fbb_.StartTable();
6442 const auto end = fbb_.EndTable(start_);
6443 auto o = flatbuffers::Offset<SliceLayer>(end);
6449 flatbuffers::FlatBufferBuilder &_fbb,
6450 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6451 flatbuffers::Offset<armnnSerializer::SliceDescriptor> descriptor = 0) {
6455 return builder_.
Finish();
6458 struct SliceDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6460 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6464 const flatbuffers::Vector<uint32_t> *
begin()
const {
6465 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_BEGIN);
6467 const flatbuffers::Vector<uint32_t> *
size()
const {
6468 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_SIZE);
6470 bool Verify(flatbuffers::Verifier &verifier)
const {
6471 return VerifyTableStart(verifier) &&
6472 VerifyOffset(verifier,
VT_BEGIN) &&
6473 verifier.VerifyVector(begin()) &&
6474 VerifyOffset(verifier, VT_SIZE) &&
6475 verifier.VerifyVector(size()) &&
6476 verifier.EndTable();
6482 flatbuffers::FlatBufferBuilder &
fbb_;
6488 fbb_.AddOffset(SliceDescriptor::VT_SIZE, size);
6492 start_ = fbb_.StartTable();
6495 flatbuffers::Offset<SliceDescriptor>
Finish() {
6496 const auto end = fbb_.EndTable(start_);
6497 auto o = flatbuffers::Offset<SliceDescriptor>(end);
6503 flatbuffers::FlatBufferBuilder &_fbb,
6509 return builder_.
Finish();
6513 flatbuffers::FlatBufferBuilder &_fbb,
6514 const std::vector<uint32_t> *begin =
nullptr,
6515 const std::vector<uint32_t> *size =
nullptr) {
6516 auto begin__ = begin ? _fbb.CreateVector<uint32_t>(*begin) : 0;
6517 auto size__ = size ? _fbb.CreateVector<uint32_t>(*size) : 0;
6524 struct StridedSliceLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6526 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6530 const armnnSerializer::LayerBase *
base()
const {
6531 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6533 const armnnSerializer::StridedSliceDescriptor *
descriptor()
const {
6534 return GetPointer<const armnnSerializer::StridedSliceDescriptor *>(
VT_DESCRIPTOR);
6536 bool Verify(flatbuffers::Verifier &verifier)
const {
6537 return VerifyTableStart(verifier) &&
6538 VerifyOffset(verifier,
VT_BASE) &&
6539 verifier.VerifyTable(base()) &&
6541 verifier.VerifyTable(descriptor()) &&
6542 verifier.EndTable();
6548 flatbuffers::FlatBufferBuilder &
fbb_;
6550 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6553 void add_descriptor(flatbuffers::Offset<armnnSerializer::StridedSliceDescriptor> descriptor) {
6558 start_ = fbb_.StartTable();
6561 flatbuffers::Offset<StridedSliceLayer>
Finish() {
6562 const auto end = fbb_.EndTable(start_);
6563 auto o = flatbuffers::Offset<StridedSliceLayer>(end);
6569 flatbuffers::FlatBufferBuilder &_fbb,
6570 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6571 flatbuffers::Offset<armnnSerializer::StridedSliceDescriptor> descriptor = 0) {
6575 return builder_.
Finish();
6578 struct StridedSliceDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6580 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6591 const flatbuffers::Vector<int32_t> *
begin()
const {
6592 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_BEGIN);
6594 const flatbuffers::Vector<int32_t> *
end()
const {
6595 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_END);
6597 const flatbuffers::Vector<int32_t> *
stride()
const {
6598 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_STRIDE);
6618 bool Verify(flatbuffers::Verifier &verifier)
const {
6619 return VerifyTableStart(verifier) &&
6620 VerifyOffset(verifier,
VT_BEGIN) &&
6621 verifier.VerifyVector(begin()) &&
6622 VerifyOffset(verifier,
VT_END) &&
6623 verifier.VerifyVector(end()) &&
6625 verifier.VerifyVector(stride()) &&
6627 VerifyField<int32_t>(verifier,
VT_ENDMASK) &&
6632 verifier.EndTable();
6638 flatbuffers::FlatBufferBuilder &
fbb_;
6669 start_ = fbb_.StartTable();
6672 flatbuffers::Offset<StridedSliceDescriptor>
Finish() {
6673 const auto end = fbb_.EndTable(start_);
6674 auto o = flatbuffers::Offset<StridedSliceDescriptor>(end);
6680 flatbuffers::FlatBufferBuilder &_fbb,
6684 int32_t beginMask = 0,
6685 int32_t endMask = 0,
6686 int32_t shrinkAxisMask = 0,
6687 int32_t ellipsisMask = 0,
6688 int32_t newAxisMask = 0,
6700 return builder_.
Finish();
6704 flatbuffers::FlatBufferBuilder &_fbb,
6705 const std::vector<int32_t> *begin =
nullptr,
6706 const std::vector<int32_t> *end =
nullptr,
6707 const std::vector<int32_t> *stride =
nullptr,
6708 int32_t beginMask = 0,
6709 int32_t endMask = 0,
6710 int32_t shrinkAxisMask = 0,
6711 int32_t ellipsisMask = 0,
6712 int32_t newAxisMask = 0,
6714 auto begin__ = begin ? _fbb.CreateVector<int32_t>(*begin) : 0;
6715 auto end__ = end ? _fbb.CreateVector<int32_t>(*end) : 0;
6716 auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0;
6730 struct ConcatLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6732 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6736 const armnnSerializer::LayerBase *
base()
const {
6737 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6740 return GetPointer<const armnnSerializer::OriginsDescriptor *>(
VT_DESCRIPTOR);
6742 bool Verify(flatbuffers::Verifier &verifier)
const {
6743 return VerifyTableStart(verifier) &&
6744 VerifyOffset(verifier,
VT_BASE) &&
6745 verifier.VerifyTable(base()) &&
6747 verifier.VerifyTable(descriptor()) &&
6748 verifier.EndTable();
6754 flatbuffers::FlatBufferBuilder &
fbb_;
6756 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6759 void add_descriptor(flatbuffers::Offset<armnnSerializer::OriginsDescriptor> descriptor) {
6764 start_ = fbb_.StartTable();
6768 const auto end = fbb_.EndTable(start_);
6769 auto o = flatbuffers::Offset<ConcatLayer>(end);
6775 flatbuffers::FlatBufferBuilder &_fbb,
6776 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6777 flatbuffers::Offset<armnnSerializer::OriginsDescriptor> descriptor = 0) {
6781 return builder_.
Finish();
6785 struct MergerLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6787 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6791 const armnnSerializer::LayerBase *
base()
const {
6792 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6795 return GetPointer<const armnnSerializer::OriginsDescriptor *>(
VT_DESCRIPTOR);
6797 bool Verify(flatbuffers::Verifier &verifier)
const {
6798 return VerifyTableStart(verifier) &&
6799 VerifyOffset(verifier,
VT_BASE) &&
6800 verifier.VerifyTable(base()) &&
6802 verifier.VerifyTable(descriptor()) &&
6803 verifier.EndTable();
6809 flatbuffers::FlatBufferBuilder &
fbb_;
6811 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6814 void add_descriptor(flatbuffers::Offset<armnnSerializer::OriginsDescriptor> descriptor) {
6819 start_ = fbb_.StartTable();
6823 const auto end = fbb_.EndTable(start_);
6824 auto o = flatbuffers::Offset<MergerLayer>(end);
6830 flatbuffers::FlatBufferBuilder &_fbb,
6831 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6832 flatbuffers::Offset<armnnSerializer::OriginsDescriptor> descriptor = 0) {
6836 return builder_.
Finish();
6839 struct UintVector FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6841 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6844 const flatbuffers::Vector<uint32_t> *
data()
const {
6845 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DATA);
6847 bool Verify(flatbuffers::Verifier &verifier)
const {
6848 return VerifyTableStart(verifier) &&
6849 VerifyOffset(verifier, VT_DATA) &&
6850 verifier.VerifyVector(data()) &&
6851 verifier.EndTable();
6857 flatbuffers::FlatBufferBuilder &
fbb_;
6860 fbb_.AddOffset(UintVector::VT_DATA, data);
6864 start_ = fbb_.StartTable();
6868 const auto end = fbb_.EndTable(start_);
6869 auto o = flatbuffers::Offset<UintVector>(end);
6875 flatbuffers::FlatBufferBuilder &_fbb,
6879 return builder_.
Finish();
6883 flatbuffers::FlatBufferBuilder &_fbb,
6884 const std::vector<uint32_t> *data =
nullptr) {
6885 auto data__ = data ? _fbb.CreateVector<uint32_t>(*data) : 0;
6891 struct OriginsDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6893 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6908 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>> *
viewOrigins()
const {
6909 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>> *>(VT_VIEWORIGINS);
6911 bool Verify(flatbuffers::Verifier &verifier)
const {
6912 return VerifyTableStart(verifier) &&
6916 VerifyOffset(verifier, VT_VIEWORIGINS) &&
6917 verifier.VerifyVector(viewOrigins()) &&
6918 verifier.VerifyVectorOfTables(viewOrigins()) &&
6919 verifier.EndTable();
6925 flatbuffers::FlatBufferBuilder &
fbb_;
6937 fbb_.AddOffset(OriginsDescriptor::VT_VIEWORIGINS, viewOrigins);
6941 start_ = fbb_.StartTable();
6944 flatbuffers::Offset<OriginsDescriptor>
Finish() {
6945 const auto end = fbb_.EndTable(start_);
6946 auto o = flatbuffers::Offset<OriginsDescriptor>(end);
6952 flatbuffers::FlatBufferBuilder &_fbb,
6953 uint32_t concatAxis = 0,
6954 uint32_t numViews = 0,
6955 uint32_t numDimensions = 0,
6956 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>>> viewOrigins = 0) {
6962 return builder_.
Finish();
6966 flatbuffers::FlatBufferBuilder &_fbb,
6967 uint32_t concatAxis = 0,
6968 uint32_t numViews = 0,
6969 uint32_t numDimensions = 0,
6970 const std::vector<flatbuffers::Offset<armnnSerializer::UintVector>> *viewOrigins =
nullptr) {
6971 auto viewOrigins__ = viewOrigins ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::UintVector>>(*viewOrigins) : 0;
6980 struct ViewsDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6982 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6986 const armnnSerializer::OriginsDescriptor *
origins()
const {
6987 return GetPointer<const armnnSerializer::OriginsDescriptor *>(
VT_ORIGINS);
6989 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>> *
viewSizes()
const {
6990 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>> *>(VT_VIEWSIZES);
6992 bool Verify(flatbuffers::Verifier &verifier)
const {
6993 return VerifyTableStart(verifier) &&
6995 verifier.VerifyTable(origins()) &&
6996 VerifyOffset(verifier, VT_VIEWSIZES) &&
6997 verifier.VerifyVector(viewSizes()) &&
6998 verifier.VerifyVectorOfTables(viewSizes()) &&
6999 verifier.EndTable();
7005 flatbuffers::FlatBufferBuilder &
fbb_;
7007 void add_origins(flatbuffers::Offset<armnnSerializer::OriginsDescriptor> origins) {
7011 fbb_.AddOffset(ViewsDescriptor::VT_VIEWSIZES, viewSizes);
7015 start_ = fbb_.StartTable();
7018 flatbuffers::Offset<ViewsDescriptor>
Finish() {
7019 const auto end = fbb_.EndTable(start_);
7020 auto o = flatbuffers::Offset<ViewsDescriptor>(end);
7026 flatbuffers::FlatBufferBuilder &_fbb,
7027 flatbuffers::Offset<armnnSerializer::OriginsDescriptor> origins = 0,
7028 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>>> viewSizes = 0) {
7032 return builder_.
Finish();
7036 flatbuffers::FlatBufferBuilder &_fbb,
7037 flatbuffers::Offset<armnnSerializer::OriginsDescriptor> origins = 0,
7038 const std::vector<flatbuffers::Offset<armnnSerializer::UintVector>> *viewSizes =
nullptr) {
7039 auto viewSizes__ = viewSizes ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::UintVector>>(*viewSizes) : 0;
7046 struct SplitterLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7048 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7052 const armnnSerializer::LayerBase *
base()
const {
7053 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
7056 return GetPointer<const armnnSerializer::ViewsDescriptor *>(
VT_DESCRIPTOR);
7058 bool Verify(flatbuffers::Verifier &verifier)
const {
7059 return VerifyTableStart(verifier) &&
7060 VerifyOffset(verifier,
VT_BASE) &&
7061 verifier.VerifyTable(base()) &&
7063 verifier.VerifyTable(descriptor()) &&
7064 verifier.EndTable();
7070 flatbuffers::FlatBufferBuilder &
fbb_;
7072 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
7075 void add_descriptor(flatbuffers::Offset<armnnSerializer::ViewsDescriptor> descriptor) {
7080 start_ = fbb_.StartTable();
7083 flatbuffers::Offset<SplitterLayer>
Finish() {
7084 const auto end = fbb_.EndTable(start_);
7085 auto o = flatbuffers::Offset<SplitterLayer>(end);
7091 flatbuffers::FlatBufferBuilder &_fbb,
7092 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7093 flatbuffers::Offset<armnnSerializer::ViewsDescriptor> descriptor = 0) {
7097 return builder_.
Finish();
7100 struct DetectionPostProcessLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7102 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7107 const armnnSerializer::LayerBase *
base()
const {
7108 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
7110 const armnnSerializer::DetectionPostProcessDescriptor *
descriptor()
const {
7111 return GetPointer<const armnnSerializer::DetectionPostProcessDescriptor *>(
VT_DESCRIPTOR);
7113 const armnnSerializer::ConstTensor *
anchors()
const {
7114 return GetPointer<const armnnSerializer::ConstTensor *>(VT_ANCHORS);
7116 bool Verify(flatbuffers::Verifier &verifier)
const {
7117 return VerifyTableStart(verifier) &&
7118 VerifyOffset(verifier,
VT_BASE) &&
7119 verifier.VerifyTable(base()) &&
7121 verifier.VerifyTable(descriptor()) &&
7122 VerifyOffset(verifier, VT_ANCHORS) &&
7123 verifier.VerifyTable(anchors()) &&
7124 verifier.EndTable();
7129 typedef DetectionPostProcessLayer
Table;
7130 flatbuffers::FlatBufferBuilder &
fbb_;
7132 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
7135 void add_descriptor(flatbuffers::Offset<armnnSerializer::DetectionPostProcessDescriptor> descriptor) {
7138 void add_anchors(flatbuffers::Offset<armnnSerializer::ConstTensor> anchors) {
7139 fbb_.AddOffset(DetectionPostProcessLayer::VT_ANCHORS, anchors);
7143 start_ = fbb_.StartTable();
7146 flatbuffers::Offset<DetectionPostProcessLayer>
Finish() {
7147 const auto end = fbb_.EndTable(start_);
7148 auto o = flatbuffers::Offset<DetectionPostProcessLayer>(end);
7154 flatbuffers::FlatBufferBuilder &_fbb,
7155 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7156 flatbuffers::Offset<armnnSerializer::DetectionPostProcessDescriptor> descriptor = 0,
7157 flatbuffers::Offset<armnnSerializer::ConstTensor> anchors = 0) {
7162 return builder_.
Finish();
7165 struct DetectionPostProcessDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7167 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7202 return GetField<float>(
VT_SCALEX, 0.0f);
7205 return GetField<float>(
VT_SCALEY, 0.0f);
7208 return GetField<float>(
VT_SCALEW, 0.0f);
7211 return GetField<float>(VT_SCALEH, 0.0f);
7213 bool Verify(flatbuffers::Verifier &verifier)
const {
7214 return VerifyTableStart(verifier) &&
7222 VerifyField<float>(verifier,
VT_SCALEX) &&
7223 VerifyField<float>(verifier,
VT_SCALEY) &&
7224 VerifyField<float>(verifier,
VT_SCALEW) &&
7225 VerifyField<float>(verifier, VT_SCALEH) &&
7226 verifier.EndTable();
7231 typedef DetectionPostProcessDescriptor
Table;
7232 flatbuffers::FlatBufferBuilder &
fbb_;
7265 fbb_.AddElement<
float>(DetectionPostProcessDescriptor::VT_SCALEH, scaleH, 0.0f);
7269 start_ = fbb_.StartTable();
7272 flatbuffers::Offset<DetectionPostProcessDescriptor>
Finish() {
7273 const auto end = fbb_.EndTable(start_);
7274 auto o = flatbuffers::Offset<DetectionPostProcessDescriptor>(end);
7280 flatbuffers::FlatBufferBuilder &_fbb,
7281 uint32_t maxDetections = 0,
7282 uint32_t maxClassesPerDetection = 0,
7283 uint32_t detectionsPerClass = 0,
7284 float nmsScoreThreshold = 0.0f,
7285 float nmsIouThreshold = 0.0f,
7286 uint32_t numClasses = 0,
7287 bool useRegularNms =
false,
7288 float scaleX = 0.0f,
7289 float scaleY = 0.0f,
7290 float scaleW = 0.0f,
7291 float scaleH = 0.0f) {
7304 return builder_.
Finish();
7307 struct LstmInputParams FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7309 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7330 VT_OUTPUTLAYERNORMWEIGHTS = 44
7354 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_CELLBIAS);
7393 return GetPointer<const armnnSerializer::ConstTensor *>(VT_OUTPUTLAYERNORMWEIGHTS);
7395 bool Verify(flatbuffers::Verifier &verifier)
const {
7396 return VerifyTableStart(verifier) &&
7398 verifier.VerifyTable(inputToForgetWeights()) &&
7400 verifier.VerifyTable(inputToCellWeights()) &&
7402 verifier.VerifyTable(inputToOutputWeights()) &&
7404 verifier.VerifyTable(recurrentToForgetWeights()) &&
7406 verifier.VerifyTable(recurrentToCellWeights()) &&
7408 verifier.VerifyTable(recurrentToOutputWeights()) &&
7410 verifier.VerifyTable(forgetGateBias()) &&
7412 verifier.VerifyTable(cellBias()) &&
7414 verifier.VerifyTable(outputGateBias()) &&
7416 verifier.VerifyTable(inputToInputWeights()) &&
7418 verifier.VerifyTable(recurrentToInputWeights()) &&
7420 verifier.VerifyTable(cellToInputWeights()) &&
7422 verifier.VerifyTable(inputGateBias()) &&
7424 verifier.VerifyTable(projectionWeights()) &&
7426 verifier.VerifyTable(projectionBias()) &&
7428 verifier.VerifyTable(cellToForgetWeights()) &&
7430 verifier.VerifyTable(cellToOutputWeights()) &&
7432 verifier.VerifyTable(inputLayerNormWeights()) &&
7434 verifier.VerifyTable(forgetLayerNormWeights()) &&
7436 verifier.VerifyTable(cellLayerNormWeights()) &&
7437 VerifyOffset(verifier, VT_OUTPUTLAYERNORMWEIGHTS) &&
7438 verifier.VerifyTable(outputLayerNormWeights()) &&
7439 verifier.EndTable();
7445 flatbuffers::FlatBufferBuilder &
fbb_;
7468 void add_cellBias(flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias) {
7508 fbb_.AddOffset(LstmInputParams::VT_OUTPUTLAYERNORMWEIGHTS, outputLayerNormWeights);
7512 start_ = fbb_.StartTable();
7515 flatbuffers::Offset<LstmInputParams>
Finish() {
7516 const auto end = fbb_.EndTable(start_);
7517 auto o = flatbuffers::Offset<LstmInputParams>(end);
7523 flatbuffers::FlatBufferBuilder &_fbb,
7524 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToForgetWeights = 0,
7525 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToCellWeights = 0,
7526 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToOutputWeights = 0,
7527 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToForgetWeights = 0,
7528 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToCellWeights = 0,
7529 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToOutputWeights = 0,
7530 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetGateBias = 0,
7531 flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias = 0,
7532 flatbuffers::Offset<armnnSerializer::ConstTensor> outputGateBias = 0,
7533 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToInputWeights = 0,
7534 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToInputWeights = 0,
7535 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToInputWeights = 0,
7536 flatbuffers::Offset<armnnSerializer::ConstTensor> inputGateBias = 0,
7537 flatbuffers::Offset<armnnSerializer::ConstTensor> projectionWeights = 0,
7538 flatbuffers::Offset<armnnSerializer::ConstTensor> projectionBias = 0,
7539 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToForgetWeights = 0,
7540 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToOutputWeights = 0,
7541 flatbuffers::Offset<armnnSerializer::ConstTensor> inputLayerNormWeights = 0,
7542 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetLayerNormWeights = 0,
7543 flatbuffers::Offset<armnnSerializer::ConstTensor> cellLayerNormWeights = 0,
7544 flatbuffers::Offset<armnnSerializer::ConstTensor> outputLayerNormWeights = 0) {
7567 return builder_.
Finish();
7570 struct LstmDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7572 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7602 bool Verify(flatbuffers::Verifier &verifier)
const {
7603 return VerifyTableStart(verifier) &&
7611 verifier.EndTable();
7617 flatbuffers::FlatBufferBuilder &
fbb_;
7642 start_ = fbb_.StartTable();
7645 flatbuffers::Offset<LstmDescriptor>
Finish() {
7646 const auto end = fbb_.EndTable(start_);
7647 auto o = flatbuffers::Offset<LstmDescriptor>(end);
7653 flatbuffers::FlatBufferBuilder &_fbb,
7654 uint32_t activationFunc = 0,
7655 float clippingThresCell = 0.0f,
7656 float clippingThresProj = 0.0f,
7657 bool cifgEnabled =
true,
7658 bool peepholeEnabled =
false,
7659 bool projectionEnabled =
false,
7660 bool layerNormEnabled =
false) {
7669 return builder_.
Finish();
7672 struct LstmLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7674 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7679 const armnnSerializer::LayerBase *
base()
const {
7680 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
7683 return GetPointer<const armnnSerializer::LstmDescriptor *>(
VT_DESCRIPTOR);
7686 return GetPointer<const armnnSerializer::LstmInputParams *>(VT_INPUTPARAMS);
7688 bool Verify(flatbuffers::Verifier &verifier)
const {
7689 return VerifyTableStart(verifier) &&
7690 VerifyOffset(verifier,
VT_BASE) &&
7691 verifier.VerifyTable(base()) &&
7693 verifier.VerifyTable(descriptor()) &&
7694 VerifyOffset(verifier, VT_INPUTPARAMS) &&
7695 verifier.VerifyTable(inputParams()) &&
7696 verifier.EndTable();
7702 flatbuffers::FlatBufferBuilder &
fbb_;
7704 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
7707 void add_descriptor(flatbuffers::Offset<armnnSerializer::LstmDescriptor> descriptor) {
7711 fbb_.AddOffset(LstmLayer::VT_INPUTPARAMS, inputParams);
7715 start_ = fbb_.StartTable();
7719 const auto end = fbb_.EndTable(start_);
7720 auto o = flatbuffers::Offset<LstmLayer>(end);
7726 flatbuffers::FlatBufferBuilder &_fbb,
7727 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7728 flatbuffers::Offset<armnnSerializer::LstmDescriptor> descriptor = 0,
7729 flatbuffers::Offset<armnnSerializer::LstmInputParams> inputParams = 0) {
7734 return builder_.
Finish();
7737 struct QLstmInputParams FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7739 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7760 VT_OUTPUTLAYERNORMWEIGHTS = 44
7784 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_CELLBIAS);
7823 return GetPointer<const armnnSerializer::ConstTensor *>(VT_OUTPUTLAYERNORMWEIGHTS);
7825 bool Verify(flatbuffers::Verifier &verifier)
const {
7826 return VerifyTableStart(verifier) &&
7828 verifier.VerifyTable(inputToForgetWeights()) &&
7830 verifier.VerifyTable(inputToCellWeights()) &&
7832 verifier.VerifyTable(inputToOutputWeights()) &&
7834 verifier.VerifyTable(recurrentToForgetWeights()) &&
7836 verifier.VerifyTable(recurrentToCellWeights()) &&
7838 verifier.VerifyTable(recurrentToOutputWeights()) &&
7840 verifier.VerifyTable(forgetGateBias()) &&
7842 verifier.VerifyTable(cellBias()) &&
7844 verifier.VerifyTable(outputGateBias()) &&
7846 verifier.VerifyTable(inputToInputWeights()) &&
7848 verifier.VerifyTable(recurrentToInputWeights()) &&
7850 verifier.VerifyTable(inputGateBias()) &&
7852 verifier.VerifyTable(projectionWeights()) &&
7854 verifier.VerifyTable(projectionBias()) &&
7856 verifier.VerifyTable(cellToInputWeights()) &&
7858 verifier.VerifyTable(cellToForgetWeights()) &&
7860 verifier.VerifyTable(cellToOutputWeights()) &&
7862 verifier.VerifyTable(inputLayerNormWeights()) &&
7864 verifier.VerifyTable(forgetLayerNormWeights()) &&
7866 verifier.VerifyTable(cellLayerNormWeights()) &&
7867 VerifyOffset(verifier, VT_OUTPUTLAYERNORMWEIGHTS) &&
7868 verifier.VerifyTable(outputLayerNormWeights()) &&
7869 verifier.EndTable();
7875 flatbuffers::FlatBufferBuilder &
fbb_;
7898 void add_cellBias(flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias) {
7938 fbb_.AddOffset(QLstmInputParams::VT_OUTPUTLAYERNORMWEIGHTS, outputLayerNormWeights);
7942 start_ = fbb_.StartTable();
7945 flatbuffers::Offset<QLstmInputParams>
Finish() {
7946 const auto end = fbb_.EndTable(start_);
7947 auto o = flatbuffers::Offset<QLstmInputParams>(end);
7953 flatbuffers::FlatBufferBuilder &_fbb,
7954 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToForgetWeights = 0,
7955 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToCellWeights = 0,
7956 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToOutputWeights = 0,
7957 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToForgetWeights = 0,
7958 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToCellWeights = 0,
7959 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToOutputWeights = 0,
7960 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetGateBias = 0,
7961 flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias = 0,
7962 flatbuffers::Offset<armnnSerializer::ConstTensor> outputGateBias = 0,
7963 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToInputWeights = 0,
7964 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToInputWeights = 0,
7965 flatbuffers::Offset<armnnSerializer::ConstTensor> inputGateBias = 0,
7966 flatbuffers::Offset<armnnSerializer::ConstTensor> projectionWeights = 0,
7967 flatbuffers::Offset<armnnSerializer::ConstTensor> projectionBias = 0,
7968 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToInputWeights = 0,
7969 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToForgetWeights = 0,
7970 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToOutputWeights = 0,
7971 flatbuffers::Offset<armnnSerializer::ConstTensor> inputLayerNormWeights = 0,
7972 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetLayerNormWeights = 0,
7973 flatbuffers::Offset<armnnSerializer::ConstTensor> cellLayerNormWeights = 0,
7974 flatbuffers::Offset<armnnSerializer::ConstTensor> outputLayerNormWeights = 0) {
7997 return builder_.
Finish();
8000 struct QLstmDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8002 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8014 VT_HIDDENSTATESCALE = 26
8050 return GetField<float>(VT_HIDDENSTATESCALE, 0.0f);
8052 bool Verify(flatbuffers::Verifier &verifier)
const {
8053 return VerifyTableStart(verifier) &&
8065 VerifyField<float>(verifier, VT_HIDDENSTATESCALE) &&
8066 verifier.EndTable();
8072 flatbuffers::FlatBufferBuilder &
fbb_;
8108 fbb_.AddElement<
float>(QLstmDescriptor::VT_HIDDENSTATESCALE, hiddenStateScale, 0.0f);
8112 start_ = fbb_.StartTable();
8115 flatbuffers::Offset<QLstmDescriptor>
Finish() {
8116 const auto end = fbb_.EndTable(start_);
8117 auto o = flatbuffers::Offset<QLstmDescriptor>(end);
8123 flatbuffers::FlatBufferBuilder &_fbb,
8124 bool cifgEnabled =
true,
8125 bool peepholeEnabled =
false,
8126 bool projectionEnabled =
false,
8127 bool layerNormEnabled =
false,
8128 float cellClip = 0.0f,
8129 float projectionClip = 0.0f,
8130 float inputIntermediateScale = 0.0f,
8131 float forgetIntermediateScale = 0.0f,
8132 float cellIntermediateScale = 0.0f,
8133 float outputIntermediateScale = 0.0f,
8134 int32_t hiddenStateZeroPoint = 0,
8135 float hiddenStateScale = 0.0f) {
8149 return builder_.
Finish();
8152 struct QLstmLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8154 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8159 const armnnSerializer::LayerBase *
base()
const {
8160 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8163 return GetPointer<const armnnSerializer::QLstmDescriptor *>(
VT_DESCRIPTOR);
8166 return GetPointer<const armnnSerializer::QLstmInputParams *>(VT_INPUTPARAMS);
8168 bool Verify(flatbuffers::Verifier &verifier)
const {
8169 return VerifyTableStart(verifier) &&
8170 VerifyOffset(verifier,
VT_BASE) &&
8171 verifier.VerifyTable(base()) &&
8173 verifier.VerifyTable(descriptor()) &&
8174 VerifyOffset(verifier, VT_INPUTPARAMS) &&
8175 verifier.VerifyTable(inputParams()) &&
8176 verifier.EndTable();
8182 flatbuffers::FlatBufferBuilder &
fbb_;
8184 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8187 void add_descriptor(flatbuffers::Offset<armnnSerializer::QLstmDescriptor> descriptor) {
8190 void add_inputParams(flatbuffers::Offset<armnnSerializer::QLstmInputParams> inputParams) {
8191 fbb_.AddOffset(QLstmLayer::VT_INPUTPARAMS, inputParams);
8195 start_ = fbb_.StartTable();
8199 const auto end = fbb_.EndTable(start_);
8200 auto o = flatbuffers::Offset<QLstmLayer>(end);
8206 flatbuffers::FlatBufferBuilder &_fbb,
8207 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
8208 flatbuffers::Offset<armnnSerializer::QLstmDescriptor> descriptor = 0,
8209 flatbuffers::Offset<armnnSerializer::QLstmInputParams> inputParams = 0) {
8214 return builder_.
Finish();
8217 struct QuantizedLstmInputParams FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8219 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8264 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_CELLBIAS);
8269 bool Verify(flatbuffers::Verifier &verifier)
const {
8270 return VerifyTableStart(verifier) &&
8272 verifier.VerifyTable(inputToInputWeights()) &&
8274 verifier.VerifyTable(inputToForgetWeights()) &&
8276 verifier.VerifyTable(inputToCellWeights()) &&
8278 verifier.VerifyTable(inputToOutputWeights()) &&
8280 verifier.VerifyTable(recurrentToInputWeights()) &&
8282 verifier.VerifyTable(recurrentToForgetWeights()) &&
8284 verifier.VerifyTable(recurrentToCellWeights()) &&
8286 verifier.VerifyTable(recurrentToOutputWeights()) &&
8288 verifier.VerifyTable(inputGateBias()) &&
8290 verifier.VerifyTable(forgetGateBias()) &&
8292 verifier.VerifyTable(cellBias()) &&
8294 verifier.VerifyTable(outputGateBias()) &&
8295 verifier.EndTable();
8301 flatbuffers::FlatBufferBuilder &
fbb_;
8333 void add_cellBias(flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias) {
8341 start_ = fbb_.StartTable();
8344 flatbuffers::Offset<QuantizedLstmInputParams>
Finish() {
8345 const auto end = fbb_.EndTable(start_);
8346 auto o = flatbuffers::Offset<QuantizedLstmInputParams>(end);
8352 flatbuffers::FlatBufferBuilder &_fbb,
8353 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToInputWeights = 0,
8354 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToForgetWeights = 0,
8355 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToCellWeights = 0,
8356 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToOutputWeights = 0,
8357 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToInputWeights = 0,
8358 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToForgetWeights = 0,
8359 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToCellWeights = 0,
8360 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToOutputWeights = 0,
8361 flatbuffers::Offset<armnnSerializer::ConstTensor> inputGateBias = 0,
8362 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetGateBias = 0,
8363 flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias = 0,
8364 flatbuffers::Offset<armnnSerializer::ConstTensor> outputGateBias = 0) {
8378 return builder_.
Finish();
8381 struct QuantizedLstmLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8383 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8387 const armnnSerializer::LayerBase *
base()
const {
8388 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8390 const armnnSerializer::QuantizedLstmInputParams *
inputParams()
const {
8391 return GetPointer<const armnnSerializer::QuantizedLstmInputParams *>(VT_INPUTPARAMS);
8393 bool Verify(flatbuffers::Verifier &verifier)
const {
8394 return VerifyTableStart(verifier) &&
8395 VerifyOffset(verifier,
VT_BASE) &&
8396 verifier.VerifyTable(base()) &&
8397 VerifyOffset(verifier, VT_INPUTPARAMS) &&
8398 verifier.VerifyTable(inputParams()) &&
8399 verifier.EndTable();
8405 flatbuffers::FlatBufferBuilder &
fbb_;
8407 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8410 void add_inputParams(flatbuffers::Offset<armnnSerializer::QuantizedLstmInputParams> inputParams) {
8411 fbb_.AddOffset(QuantizedLstmLayer::VT_INPUTPARAMS, inputParams);
8415 start_ = fbb_.StartTable();
8418 flatbuffers::Offset<QuantizedLstmLayer>
Finish() {
8419 const auto end = fbb_.EndTable(start_);
8420 auto o = flatbuffers::Offset<QuantizedLstmLayer>(end);
8426 flatbuffers::FlatBufferBuilder &_fbb,
8427 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
8428 flatbuffers::Offset<armnnSerializer::QuantizedLstmInputParams> inputParams = 0) {
8432 return builder_.
Finish();
8435 struct DequantizeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8437 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8440 const armnnSerializer::LayerBase *
base()
const {
8441 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8443 bool Verify(flatbuffers::Verifier &verifier)
const {
8444 return VerifyTableStart(verifier) &&
8445 VerifyOffset(verifier,
VT_BASE) &&
8446 verifier.VerifyTable(base()) &&
8447 verifier.EndTable();
8453 flatbuffers::FlatBufferBuilder &
fbb_;
8455 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8460 start_ = fbb_.StartTable();
8463 flatbuffers::Offset<DequantizeLayer>
Finish() {
8464 const auto end = fbb_.EndTable(start_);
8465 auto o = flatbuffers::Offset<DequantizeLayer>(end);
8471 flatbuffers::FlatBufferBuilder &_fbb,
8472 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
8475 return builder_.
Finish();
8478 struct MergeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8480 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8483 const armnnSerializer::LayerBase *
base()
const {
8484 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8486 bool Verify(flatbuffers::Verifier &verifier)
const {
8487 return VerifyTableStart(verifier) &&
8488 VerifyOffset(verifier,
VT_BASE) &&
8489 verifier.VerifyTable(base()) &&
8490 verifier.EndTable();
8496 flatbuffers::FlatBufferBuilder &
fbb_;
8498 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8503 start_ = fbb_.StartTable();
8507 const auto end = fbb_.EndTable(start_);
8508 auto o = flatbuffers::Offset<MergeLayer>(end);
8514 flatbuffers::FlatBufferBuilder &_fbb,
8515 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
8518 return builder_.
Finish();
8521 struct SwitchLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8523 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8526 const armnnSerializer::LayerBase *
base()
const {
8527 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8529 bool Verify(flatbuffers::Verifier &verifier)
const {
8530 return VerifyTableStart(verifier) &&
8531 VerifyOffset(verifier,
VT_BASE) &&
8532 verifier.VerifyTable(base()) &&
8533 verifier.EndTable();
8539 flatbuffers::FlatBufferBuilder &
fbb_;
8541 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8546 start_ = fbb_.StartTable();
8550 const auto end = fbb_.EndTable(start_);
8551 auto o = flatbuffers::Offset<SwitchLayer>(end);
8557 flatbuffers::FlatBufferBuilder &_fbb,
8558 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
8561 return builder_.
Finish();
8564 struct PreluLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8566 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8569 const armnnSerializer::LayerBase *
base()
const {
8570 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8572 bool Verify(flatbuffers::Verifier &verifier)
const {
8573 return VerifyTableStart(verifier) &&
8574 VerifyOffset(verifier,
VT_BASE) &&
8575 verifier.VerifyTable(base()) &&
8576 verifier.EndTable();
8582 flatbuffers::FlatBufferBuilder &
fbb_;
8584 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8589 start_ = fbb_.StartTable();
8593 const auto end = fbb_.EndTable(start_);
8594 auto o = flatbuffers::Offset<PreluLayer>(end);
8600 flatbuffers::FlatBufferBuilder &_fbb,
8601 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
8604 return builder_.
Finish();
8607 struct TransposeConvolution2dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8609 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8615 const armnnSerializer::LayerBase *
base()
const {
8616 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8618 const armnnSerializer::TransposeConvolution2dDescriptor *
descriptor()
const {
8619 return GetPointer<const armnnSerializer::TransposeConvolution2dDescriptor *>(
VT_DESCRIPTOR);
8621 const armnnSerializer::ConstTensor *
weights()
const {
8622 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_WEIGHTS);
8624 const armnnSerializer::ConstTensor *
biases()
const {
8625 return GetPointer<const armnnSerializer::ConstTensor *>(VT_BIASES);
8627 bool Verify(flatbuffers::Verifier &verifier)
const {
8628 return VerifyTableStart(verifier) &&
8629 VerifyOffset(verifier,
VT_BASE) &&
8630 verifier.VerifyTable(base()) &&
8632 verifier.VerifyTable(descriptor()) &&
8634 verifier.VerifyTable(weights()) &&
8635 VerifyOffset(verifier, VT_BIASES) &&
8636 verifier.VerifyTable(biases()) &&
8637 verifier.EndTable();
8642 typedef TransposeConvolution2dLayer
Table;
8643 flatbuffers::FlatBufferBuilder &
fbb_;
8645 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8648 void add_descriptor(flatbuffers::Offset<armnnSerializer::TransposeConvolution2dDescriptor> descriptor) {
8651 void add_weights(flatbuffers::Offset<armnnSerializer::ConstTensor> weights) {
8654 void add_biases(flatbuffers::Offset<armnnSerializer::ConstTensor> biases) {
8655 fbb_.AddOffset(TransposeConvolution2dLayer::VT_BIASES, biases);
8659 start_ = fbb_.StartTable();
8662 flatbuffers::Offset<TransposeConvolution2dLayer>
Finish() {
8663 const auto end = fbb_.EndTable(start_);
8664 auto o = flatbuffers::Offset<TransposeConvolution2dLayer>(end);
8670 flatbuffers::FlatBufferBuilder &_fbb,
8671 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
8672 flatbuffers::Offset<armnnSerializer::TransposeConvolution2dDescriptor> descriptor = 0,
8673 flatbuffers::Offset<armnnSerializer::ConstTensor> weights = 0,
8674 flatbuffers::Offset<armnnSerializer::ConstTensor> biases = 0) {
8680 return builder_.
Finish();
8683 struct TransposeConvolution2dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8685 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8702 return GetField<uint32_t>(
VT_PADTOP, 0);
8719 bool Verify(flatbuffers::Verifier &verifier)
const {
8720 return VerifyTableStart(verifier) &&
8721 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
8723 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
8725 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
8726 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
8729 verifier.EndTable();
8734 typedef TransposeConvolution2dDescriptor
Table;
8735 flatbuffers::FlatBufferBuilder &
fbb_;
8763 start_ = fbb_.StartTable();
8766 flatbuffers::Offset<TransposeConvolution2dDescriptor>
Finish() {
8767 const auto end = fbb_.EndTable(start_);
8768 auto o = flatbuffers::Offset<TransposeConvolution2dDescriptor>(end);
8774 flatbuffers::FlatBufferBuilder &_fbb,
8775 uint32_t padLeft = 0,
8776 uint32_t padRight = 0,
8777 uint32_t padTop = 0,
8778 uint32_t padBottom = 0,
8779 uint32_t strideX = 0,
8780 uint32_t strideY = 0,
8781 bool biasEnabled =
false,
8792 return builder_.
Finish();
8795 struct TransposeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8797 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8801 const armnnSerializer::LayerBase *
base()
const {
8802 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8805 return GetPointer<const armnnSerializer::TransposeDescriptor *>(
VT_DESCRIPTOR);
8807 bool Verify(flatbuffers::Verifier &verifier)
const {
8808 return VerifyTableStart(verifier) &&
8809 VerifyOffset(verifier,
VT_BASE) &&
8810 verifier.VerifyTable(base()) &&
8812 verifier.VerifyTable(descriptor()) &&
8813 verifier.EndTable();
8819 flatbuffers::FlatBufferBuilder &
fbb_;
8821 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8824 void add_descriptor(flatbuffers::Offset<armnnSerializer::TransposeDescriptor> descriptor) {
8829 start_ = fbb_.StartTable();
8832 flatbuffers::Offset<TransposeLayer>
Finish() {
8833 const auto end = fbb_.EndTable(start_);
8834 auto o = flatbuffers::Offset<TransposeLayer>(end);
8840 flatbuffers::FlatBufferBuilder &_fbb,
8841 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
8842 flatbuffers::Offset<armnnSerializer::TransposeDescriptor> descriptor = 0) {
8846 return builder_.
Finish();
8849 struct TransposeDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8851 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8855 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DIMMAPPINGS);
8857 bool Verify(flatbuffers::Verifier &verifier)
const {
8858 return VerifyTableStart(verifier) &&
8859 VerifyOffset(verifier, VT_DIMMAPPINGS) &&
8860 verifier.VerifyVector(dimMappings()) &&
8861 verifier.EndTable();
8867 flatbuffers::FlatBufferBuilder &
fbb_;
8870 fbb_.AddOffset(TransposeDescriptor::VT_DIMMAPPINGS, dimMappings);
8874 start_ = fbb_.StartTable();
8877 flatbuffers::Offset<TransposeDescriptor>
Finish() {
8878 const auto end = fbb_.EndTable(start_);
8879 auto o = flatbuffers::Offset<TransposeDescriptor>(end);
8885 flatbuffers::FlatBufferBuilder &_fbb,
8889 return builder_.
Finish();
8893 flatbuffers::FlatBufferBuilder &_fbb,
8894 const std::vector<uint32_t> *dimMappings =
nullptr) {
8895 auto dimMappings__ = dimMappings ? _fbb.CreateVector<uint32_t>(*dimMappings) : 0;
8901 struct ResizeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8903 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8907 const armnnSerializer::LayerBase *
base()
const {
8908 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8911 return GetPointer<const armnnSerializer::ResizeDescriptor *>(
VT_DESCRIPTOR);
8913 bool Verify(flatbuffers::Verifier &verifier)
const {
8914 return VerifyTableStart(verifier) &&
8915 VerifyOffset(verifier,
VT_BASE) &&
8916 verifier.VerifyTable(base()) &&
8918 verifier.VerifyTable(descriptor()) &&
8919 verifier.EndTable();
8925 flatbuffers::FlatBufferBuilder &
fbb_;
8927 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8930 void add_descriptor(flatbuffers::Offset<armnnSerializer::ResizeDescriptor> descriptor) {
8935 start_ = fbb_.StartTable();
8939 const auto end = fbb_.EndTable(start_);
8940 auto o = flatbuffers::Offset<ResizeLayer>(end);
8946 flatbuffers::FlatBufferBuilder &_fbb,
8947 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
8948 flatbuffers::Offset<armnnSerializer::ResizeDescriptor> descriptor = 0) {
8952 return builder_.
Finish();
8955 struct ResizeDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8957 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8963 VT_HALFPIXELCENTERS = 14
8981 return GetField<uint8_t>(VT_HALFPIXELCENTERS, 0) != 0;
8983 bool Verify(flatbuffers::Verifier &verifier)
const {
8984 return VerifyTableStart(verifier) &&
8987 VerifyField<int8_t>(verifier,
VT_METHOD) &&
8990 VerifyField<uint8_t>(verifier, VT_HALFPIXELCENTERS) &&
8991 verifier.EndTable();
8997 flatbuffers::FlatBufferBuilder &
fbb_;
9015 fbb_.AddElement<uint8_t>(ResizeDescriptor::VT_HALFPIXELCENTERS,
static_cast<uint8_t
>(halfPixelCenters), 0);
9019 start_ = fbb_.StartTable();
9022 flatbuffers::Offset<ResizeDescriptor>
Finish() {
9023 const auto end = fbb_.EndTable(start_);
9024 auto o = flatbuffers::Offset<ResizeDescriptor>(end);
9030 flatbuffers::FlatBufferBuilder &_fbb,
9031 uint32_t targetHeight = 0,
9032 uint32_t targetWidth = 0,
9035 bool alignCorners =
false,
9036 bool halfPixelCenters =
false) {
9044 return builder_.
Finish();
9047 struct StackLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9049 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9053 const armnnSerializer::LayerBase *
base()
const {
9054 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9057 return GetPointer<const armnnSerializer::StackDescriptor *>(
VT_DESCRIPTOR);
9059 bool Verify(flatbuffers::Verifier &verifier)
const {
9060 return VerifyTableStart(verifier) &&
9061 VerifyOffset(verifier,
VT_BASE) &&
9062 verifier.VerifyTable(base()) &&
9064 verifier.VerifyTable(descriptor()) &&
9065 verifier.EndTable();
9071 flatbuffers::FlatBufferBuilder &
fbb_;
9073 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9076 void add_descriptor(flatbuffers::Offset<armnnSerializer::StackDescriptor> descriptor) {
9081 start_ = fbb_.StartTable();
9085 const auto end = fbb_.EndTable(start_);
9086 auto o = flatbuffers::Offset<StackLayer>(end);
9092 flatbuffers::FlatBufferBuilder &_fbb,
9093 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9094 flatbuffers::Offset<armnnSerializer::StackDescriptor> descriptor = 0) {
9098 return builder_.
Finish();
9101 struct StackDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9103 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9109 return GetField<uint32_t>(
VT_AXIS, 0);
9115 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_INPUTSHAPE);
9117 bool Verify(flatbuffers::Verifier &verifier)
const {
9118 return VerifyTableStart(verifier) &&
9119 VerifyField<uint32_t>(verifier,
VT_AXIS) &&
9121 VerifyOffset(verifier, VT_INPUTSHAPE) &&
9122 verifier.VerifyVector(inputShape()) &&
9123 verifier.EndTable();
9129 flatbuffers::FlatBufferBuilder &
fbb_;
9138 fbb_.AddOffset(StackDescriptor::VT_INPUTSHAPE, inputShape);
9142 start_ = fbb_.StartTable();
9145 flatbuffers::Offset<StackDescriptor>
Finish() {
9146 const auto end = fbb_.EndTable(start_);
9147 auto o = flatbuffers::Offset<StackDescriptor>(end);
9153 flatbuffers::FlatBufferBuilder &_fbb,
9155 uint32_t numInputs = 0,
9161 return builder_.
Finish();
9165 flatbuffers::FlatBufferBuilder &_fbb,
9167 uint32_t numInputs = 0,
9168 const std::vector<uint32_t> *inputShape =
nullptr) {
9169 auto inputShape__ = inputShape ? _fbb.CreateVector<uint32_t>(*inputShape) : 0;
9177 struct StandInDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9179 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9187 return GetField<uint32_t>(VT_NUMOUTPUTS, 0);
9189 bool Verify(flatbuffers::Verifier &verifier)
const {
9190 return VerifyTableStart(verifier) &&
9192 VerifyField<uint32_t>(verifier, VT_NUMOUTPUTS) &&
9193 verifier.EndTable();
9199 flatbuffers::FlatBufferBuilder &
fbb_;
9205 fbb_.AddElement<uint32_t>(StandInDescriptor::VT_NUMOUTPUTS, numOutputs, 0);
9209 start_ = fbb_.StartTable();
9212 flatbuffers::Offset<StandInDescriptor>
Finish() {
9213 const auto end = fbb_.EndTable(start_);
9214 auto o = flatbuffers::Offset<StandInDescriptor>(end);
9220 flatbuffers::FlatBufferBuilder &_fbb,
9221 uint32_t numInputs = 0,
9222 uint32_t numOutputs = 0) {
9226 return builder_.
Finish();
9229 struct StandInLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9231 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9235 const armnnSerializer::LayerBase *
base()
const {
9236 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9239 return GetPointer<const armnnSerializer::StandInDescriptor *>(
VT_DESCRIPTOR);
9241 bool Verify(flatbuffers::Verifier &verifier)
const {
9242 return VerifyTableStart(verifier) &&
9243 VerifyOffset(verifier,
VT_BASE) &&
9244 verifier.VerifyTable(base()) &&
9246 verifier.VerifyTable(descriptor()) &&
9247 verifier.EndTable();
9253 flatbuffers::FlatBufferBuilder &
fbb_;
9255 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9258 void add_descriptor(flatbuffers::Offset<armnnSerializer::StandInDescriptor> descriptor) {
9263 start_ = fbb_.StartTable();
9267 const auto end = fbb_.EndTable(start_);
9268 auto o = flatbuffers::Offset<StandInLayer>(end);
9274 flatbuffers::FlatBufferBuilder &_fbb,
9275 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9276 flatbuffers::Offset<armnnSerializer::StandInDescriptor> descriptor = 0) {
9280 return builder_.
Finish();
9283 struct RankLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9285 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9288 const armnnSerializer::LayerBase *
base()
const {
9289 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9291 bool Verify(flatbuffers::Verifier &verifier)
const {
9292 return VerifyTableStart(verifier) &&
9293 VerifyOffset(verifier,
VT_BASE) &&
9294 verifier.VerifyTable(base()) &&
9295 verifier.EndTable();
9301 flatbuffers::FlatBufferBuilder &
fbb_;
9303 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9308 start_ = fbb_.StartTable();
9312 const auto end = fbb_.EndTable(start_);
9313 auto o = flatbuffers::Offset<RankLayer>(end);
9319 flatbuffers::FlatBufferBuilder &_fbb,
9320 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
9323 return builder_.
Finish();
9326 struct ReduceLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9328 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9332 const armnnSerializer::LayerBase *
base()
const {
9333 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9336 return GetPointer<const armnnSerializer::ReduceDescriptor *>(
VT_DESCRIPTOR);
9338 bool Verify(flatbuffers::Verifier &verifier)
const {
9339 return VerifyTableStart(verifier) &&
9340 VerifyOffset(verifier,
VT_BASE) &&
9341 verifier.VerifyTable(base()) &&
9343 verifier.VerifyTable(descriptor()) &&
9344 verifier.EndTable();
9350 flatbuffers::FlatBufferBuilder &
fbb_;
9352 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9355 void add_descriptor(flatbuffers::Offset<armnnSerializer::ReduceDescriptor> descriptor) {
9360 start_ = fbb_.StartTable();
9364 const auto end = fbb_.EndTable(start_);
9365 auto o = flatbuffers::Offset<ReduceLayer>(end);
9371 flatbuffers::FlatBufferBuilder &_fbb,
9372 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9373 flatbuffers::Offset<armnnSerializer::ReduceDescriptor> descriptor = 0) {
9377 return builder_.
Finish();
9380 struct ReduceDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9382 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9385 VT_REDUCEOPERATION = 8
9390 const flatbuffers::Vector<uint32_t> *
axis()
const {
9391 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_AXIS);
9396 bool Verify(flatbuffers::Verifier &verifier)
const {
9397 return VerifyTableStart(verifier) &&
9399 VerifyOffset(verifier,
VT_AXIS) &&
9400 verifier.VerifyVector(axis()) &&
9401 VerifyField<int8_t>(verifier, VT_REDUCEOPERATION) &&
9402 verifier.EndTable();
9408 flatbuffers::FlatBufferBuilder &
fbb_;
9417 fbb_.AddElement<int8_t>(ReduceDescriptor::VT_REDUCEOPERATION,
static_cast<int8_t
>(reduceOperation), 0);
9421 start_ = fbb_.StartTable();
9424 flatbuffers::Offset<ReduceDescriptor>
Finish() {
9425 const auto end = fbb_.EndTable(start_);
9426 auto o = flatbuffers::Offset<ReduceDescriptor>(end);
9432 flatbuffers::FlatBufferBuilder &_fbb,
9433 bool keepDims =
false,
9440 return builder_.
Finish();
9444 flatbuffers::FlatBufferBuilder &_fbb,
9445 bool keepDims =
false,
9446 const std::vector<uint32_t> *axis =
nullptr,
9448 auto axis__ = axis ? _fbb.CreateVector<uint32_t>(*axis) : 0;
9458 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9490 return GetField<uint8_t>(VT_TIMEMAJOR, 0) != 0;
9492 bool Verify(flatbuffers::Verifier &verifier)
const {
9493 return VerifyTableStart(verifier) &&
9501 VerifyField<uint8_t>(verifier, VT_TIMEMAJOR) &&
9502 verifier.EndTable();
9508 flatbuffers::FlatBufferBuilder &
fbb_;
9532 fbb_.AddElement<uint8_t>(UnidirectionalSequenceLstmDescriptor::VT_TIMEMAJOR,
static_cast<uint8_t
>(timeMajor), 0);
9536 start_ = fbb_.StartTable();
9539 flatbuffers::Offset<UnidirectionalSequenceLstmDescriptor>
Finish() {
9540 const auto end = fbb_.EndTable(start_);
9541 auto o = flatbuffers::Offset<UnidirectionalSequenceLstmDescriptor>(end);
9547 flatbuffers::FlatBufferBuilder &_fbb,
9548 uint32_t activationFunc = 0,
9549 float clippingThresCell = 0.0f,
9550 float clippingThresProj = 0.0f,
9551 bool cifgEnabled =
true,
9552 bool peepholeEnabled =
false,
9553 bool projectionEnabled =
false,
9554 bool layerNormEnabled =
false,
9555 bool timeMajor =
false) {
9565 return builder_.
Finish();
9568 struct UnidirectionalSequenceLstmLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9570 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9575 const armnnSerializer::LayerBase *
base()
const {
9576 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9579 return GetPointer<const armnnSerializer::UnidirectionalSequenceLstmDescriptor *>(
VT_DESCRIPTOR);
9582 return GetPointer<const armnnSerializer::LstmInputParams *>(VT_INPUTPARAMS);
9584 bool Verify(flatbuffers::Verifier &verifier)
const {
9585 return VerifyTableStart(verifier) &&
9586 VerifyOffset(verifier,
VT_BASE) &&
9587 verifier.VerifyTable(base()) &&
9589 verifier.VerifyTable(descriptor()) &&
9590 VerifyOffset(verifier, VT_INPUTPARAMS) &&
9591 verifier.VerifyTable(inputParams()) &&
9592 verifier.EndTable();
9597 typedef UnidirectionalSequenceLstmLayer
Table;
9598 flatbuffers::FlatBufferBuilder &
fbb_;
9600 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9603 void add_descriptor(flatbuffers::Offset<armnnSerializer::UnidirectionalSequenceLstmDescriptor> descriptor) {
9607 fbb_.AddOffset(UnidirectionalSequenceLstmLayer::VT_INPUTPARAMS, inputParams);
9611 start_ = fbb_.StartTable();
9614 flatbuffers::Offset<UnidirectionalSequenceLstmLayer>
Finish() {
9615 const auto end = fbb_.EndTable(start_);
9616 auto o = flatbuffers::Offset<UnidirectionalSequenceLstmLayer>(end);
9622 flatbuffers::FlatBufferBuilder &_fbb,
9623 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9624 flatbuffers::Offset<armnnSerializer::UnidirectionalSequenceLstmDescriptor> descriptor = 0,
9625 flatbuffers::Offset<armnnSerializer::LstmInputParams> inputParams = 0) {
9630 return builder_.
Finish();
9633 struct AnyLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9635 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9643 return GetPointer<const void *>(VT_LAYER);
9645 template<
typename T>
const T *layer_as()
const;
9838 bool Verify(flatbuffers::Verifier &verifier)
const {
9839 return VerifyTableStart(verifier) &&
9841 VerifyOffset(verifier, VT_LAYER) &&
9843 verifier.EndTable();
9847 template<>
inline const armnnSerializer::ActivationLayer *AnyLayer::layer_as<armnnSerializer::ActivationLayer>()
const {
9848 return layer_as_ActivationLayer();
9851 template<>
inline const armnnSerializer::AdditionLayer *AnyLayer::layer_as<armnnSerializer::AdditionLayer>()
const {
9852 return layer_as_AdditionLayer();
9855 template<>
inline const armnnSerializer::BatchToSpaceNdLayer *AnyLayer::layer_as<armnnSerializer::BatchToSpaceNdLayer>()
const {
9856 return layer_as_BatchToSpaceNdLayer();
9859 template<>
inline const armnnSerializer::BatchNormalizationLayer *AnyLayer::layer_as<armnnSerializer::BatchNormalizationLayer>()
const {
9860 return layer_as_BatchNormalizationLayer();
9863 template<>
inline const armnnSerializer::ConstantLayer *AnyLayer::layer_as<armnnSerializer::ConstantLayer>()
const {
9864 return layer_as_ConstantLayer();
9867 template<>
inline const armnnSerializer::Convolution2dLayer *AnyLayer::layer_as<armnnSerializer::Convolution2dLayer>()
const {
9868 return layer_as_Convolution2dLayer();
9871 template<>
inline const armnnSerializer::DepthwiseConvolution2dLayer *AnyLayer::layer_as<armnnSerializer::DepthwiseConvolution2dLayer>()
const {
9872 return layer_as_DepthwiseConvolution2dLayer();
9875 template<>
inline const armnnSerializer::FullyConnectedLayer *AnyLayer::layer_as<armnnSerializer::FullyConnectedLayer>()
const {
9876 return layer_as_FullyConnectedLayer();
9879 template<>
inline const armnnSerializer::InputLayer *AnyLayer::layer_as<armnnSerializer::InputLayer>()
const {
9880 return layer_as_InputLayer();
9883 template<>
inline const armnnSerializer::MultiplicationLayer *AnyLayer::layer_as<armnnSerializer::MultiplicationLayer>()
const {
9884 return layer_as_MultiplicationLayer();
9887 template<>
inline const armnnSerializer::OutputLayer *AnyLayer::layer_as<armnnSerializer::OutputLayer>()
const {
9888 return layer_as_OutputLayer();
9891 template<>
inline const armnnSerializer::PermuteLayer *AnyLayer::layer_as<armnnSerializer::PermuteLayer>()
const {
9892 return layer_as_PermuteLayer();
9895 template<>
inline const armnnSerializer::Pooling2dLayer *AnyLayer::layer_as<armnnSerializer::Pooling2dLayer>()
const {
9896 return layer_as_Pooling2dLayer();
9899 template<>
inline const armnnSerializer::ReshapeLayer *AnyLayer::layer_as<armnnSerializer::ReshapeLayer>()
const {
9900 return layer_as_ReshapeLayer();
9903 template<>
inline const armnnSerializer::SoftmaxLayer *AnyLayer::layer_as<armnnSerializer::SoftmaxLayer>()
const {
9904 return layer_as_SoftmaxLayer();
9907 template<>
inline const armnnSerializer::SpaceToBatchNdLayer *AnyLayer::layer_as<armnnSerializer::SpaceToBatchNdLayer>()
const {
9908 return layer_as_SpaceToBatchNdLayer();
9911 template<>
inline const armnnSerializer::DivisionLayer *AnyLayer::layer_as<armnnSerializer::DivisionLayer>()
const {
9912 return layer_as_DivisionLayer();
9915 template<>
inline const armnnSerializer::MinimumLayer *AnyLayer::layer_as<armnnSerializer::MinimumLayer>()
const {
9916 return layer_as_MinimumLayer();
9919 template<>
inline const armnnSerializer::EqualLayer *AnyLayer::layer_as<armnnSerializer::EqualLayer>()
const {
9920 return layer_as_EqualLayer();
9923 template<>
inline const armnnSerializer::MaximumLayer *AnyLayer::layer_as<armnnSerializer::MaximumLayer>()
const {
9924 return layer_as_MaximumLayer();
9927 template<>
inline const armnnSerializer::NormalizationLayer *AnyLayer::layer_as<armnnSerializer::NormalizationLayer>()
const {
9928 return layer_as_NormalizationLayer();
9931 template<>
inline const armnnSerializer::PadLayer *AnyLayer::layer_as<armnnSerializer::PadLayer>()
const {
9932 return layer_as_PadLayer();
9935 template<>
inline const armnnSerializer::RsqrtLayer *AnyLayer::layer_as<armnnSerializer::RsqrtLayer>()
const {
9936 return layer_as_RsqrtLayer();
9939 template<>
inline const armnnSerializer::FloorLayer *AnyLayer::layer_as<armnnSerializer::FloorLayer>()
const {
9940 return layer_as_FloorLayer();
9943 template<>
inline const armnnSerializer::GreaterLayer *AnyLayer::layer_as<armnnSerializer::GreaterLayer>()
const {
9944 return layer_as_GreaterLayer();
9947 template<>
inline const armnnSerializer::ResizeBilinearLayer *AnyLayer::layer_as<armnnSerializer::ResizeBilinearLayer>()
const {
9948 return layer_as_ResizeBilinearLayer();
9951 template<>
inline const armnnSerializer::SubtractionLayer *AnyLayer::layer_as<armnnSerializer::SubtractionLayer>()
const {
9952 return layer_as_SubtractionLayer();
9955 template<>
inline const armnnSerializer::StridedSliceLayer *AnyLayer::layer_as<armnnSerializer::StridedSliceLayer>()
const {
9956 return layer_as_StridedSliceLayer();
9959 template<>
inline const armnnSerializer::GatherLayer *AnyLayer::layer_as<armnnSerializer::GatherLayer>()
const {
9960 return layer_as_GatherLayer();
9963 template<>
inline const armnnSerializer::MeanLayer *AnyLayer::layer_as<armnnSerializer::MeanLayer>()
const {
9964 return layer_as_MeanLayer();
9968 return layer_as_MergerLayer();
9971 template<>
inline const armnnSerializer::L2NormalizationLayer *AnyLayer::layer_as<armnnSerializer::L2NormalizationLayer>()
const {
9972 return layer_as_L2NormalizationLayer();
9975 template<>
inline const armnnSerializer::SplitterLayer *AnyLayer::layer_as<armnnSerializer::SplitterLayer>()
const {
9976 return layer_as_SplitterLayer();
9979 template<>
inline const armnnSerializer::DetectionPostProcessLayer *AnyLayer::layer_as<armnnSerializer::DetectionPostProcessLayer>()
const {
9980 return layer_as_DetectionPostProcessLayer();
9983 template<>
inline const armnnSerializer::LstmLayer *AnyLayer::layer_as<armnnSerializer::LstmLayer>()
const {
9984 return layer_as_LstmLayer();
9987 template<>
inline const armnnSerializer::QuantizedLstmLayer *AnyLayer::layer_as<armnnSerializer::QuantizedLstmLayer>()
const {
9988 return layer_as_QuantizedLstmLayer();
9991 template<>
inline const armnnSerializer::QuantizeLayer *AnyLayer::layer_as<armnnSerializer::QuantizeLayer>()
const {
9992 return layer_as_QuantizeLayer();
9995 template<>
inline const armnnSerializer::DequantizeLayer *AnyLayer::layer_as<armnnSerializer::DequantizeLayer>()
const {
9996 return layer_as_DequantizeLayer();
9999 template<>
inline const armnnSerializer::MergeLayer *AnyLayer::layer_as<armnnSerializer::MergeLayer>()
const {
10000 return layer_as_MergeLayer();
10003 template<>
inline const armnnSerializer::SwitchLayer *AnyLayer::layer_as<armnnSerializer::SwitchLayer>()
const {
10004 return layer_as_SwitchLayer();
10007 template<>
inline const armnnSerializer::ConcatLayer *AnyLayer::layer_as<armnnSerializer::ConcatLayer>()
const {
10008 return layer_as_ConcatLayer();
10011 template<>
inline const armnnSerializer::SpaceToDepthLayer *AnyLayer::layer_as<armnnSerializer::SpaceToDepthLayer>()
const {
10012 return layer_as_SpaceToDepthLayer();
10015 template<>
inline const armnnSerializer::PreluLayer *AnyLayer::layer_as<armnnSerializer::PreluLayer>()
const {
10016 return layer_as_PreluLayer();
10019 template<>
inline const armnnSerializer::TransposeConvolution2dLayer *AnyLayer::layer_as<armnnSerializer::TransposeConvolution2dLayer>()
const {
10020 return layer_as_TransposeConvolution2dLayer();
10023 template<>
inline const armnnSerializer::ResizeLayer *AnyLayer::layer_as<armnnSerializer::ResizeLayer>()
const {
10024 return layer_as_ResizeLayer();
10027 template<>
inline const armnnSerializer::StackLayer *AnyLayer::layer_as<armnnSerializer::StackLayer>()
const {
10028 return layer_as_StackLayer();
10031 template<>
inline const armnnSerializer::AbsLayer *AnyLayer::layer_as<armnnSerializer::AbsLayer>()
const {
10032 return layer_as_AbsLayer();
10035 template<>
inline const armnnSerializer::ArgMinMaxLayer *AnyLayer::layer_as<armnnSerializer::ArgMinMaxLayer>()
const {
10036 return layer_as_ArgMinMaxLayer();
10039 template<>
inline const armnnSerializer::SliceLayer *AnyLayer::layer_as<armnnSerializer::SliceLayer>()
const {
10040 return layer_as_SliceLayer();
10043 template<>
inline const armnnSerializer::DepthToSpaceLayer *AnyLayer::layer_as<armnnSerializer::DepthToSpaceLayer>()
const {
10044 return layer_as_DepthToSpaceLayer();
10047 template<>
inline const armnnSerializer::InstanceNormalizationLayer *AnyLayer::layer_as<armnnSerializer::InstanceNormalizationLayer>()
const {
10048 return layer_as_InstanceNormalizationLayer();
10051 template<>
inline const armnnSerializer::LogSoftmaxLayer *AnyLayer::layer_as<armnnSerializer::LogSoftmaxLayer>()
const {
10052 return layer_as_LogSoftmaxLayer();
10055 template<>
inline const armnnSerializer::ComparisonLayer *AnyLayer::layer_as<armnnSerializer::ComparisonLayer>()
const {
10056 return layer_as_ComparisonLayer();
10059 template<>
inline const armnnSerializer::StandInLayer *AnyLayer::layer_as<armnnSerializer::StandInLayer>()
const {
10060 return layer_as_StandInLayer();
10063 template<>
inline const armnnSerializer::ElementwiseUnaryLayer *AnyLayer::layer_as<armnnSerializer::ElementwiseUnaryLayer>()
const {
10064 return layer_as_ElementwiseUnaryLayer();
10067 template<>
inline const armnnSerializer::TransposeLayer *AnyLayer::layer_as<armnnSerializer::TransposeLayer>()
const {
10068 return layer_as_TransposeLayer();
10071 template<>
inline const armnnSerializer::QLstmLayer *AnyLayer::layer_as<armnnSerializer::QLstmLayer>()
const {
10072 return layer_as_QLstmLayer();
10075 template<>
inline const armnnSerializer::FillLayer *AnyLayer::layer_as<armnnSerializer::FillLayer>()
const {
10076 return layer_as_FillLayer();
10079 template<>
inline const armnnSerializer::RankLayer *AnyLayer::layer_as<armnnSerializer::RankLayer>()
const {
10080 return layer_as_RankLayer();
10083 template<>
inline const armnnSerializer::LogicalBinaryLayer *AnyLayer::layer_as<armnnSerializer::LogicalBinaryLayer>()
const {
10084 return layer_as_LogicalBinaryLayer();
10087 template<>
inline const armnnSerializer::ReduceLayer *AnyLayer::layer_as<armnnSerializer::ReduceLayer>()
const {
10088 return layer_as_ReduceLayer();
10091 template<>
inline const armnnSerializer::CastLayer *AnyLayer::layer_as<armnnSerializer::CastLayer>()
const {
10092 return layer_as_CastLayer();
10095 template<>
inline const armnnSerializer::ShapeLayer *AnyLayer::layer_as<armnnSerializer::ShapeLayer>()
const {
10096 return layer_as_ShapeLayer();
10099 template<>
inline const armnnSerializer::UnidirectionalSequenceLstmLayer *AnyLayer::layer_as<armnnSerializer::UnidirectionalSequenceLstmLayer>()
const {
10100 return layer_as_UnidirectionalSequenceLstmLayer();
10111 fbb_.AddOffset(AnyLayer::VT_LAYER, layer);
10115 start_ = fbb_.StartTable();
10119 const auto end = fbb_.EndTable(start_);
10120 auto o = flatbuffers::Offset<AnyLayer>(end);
10126 flatbuffers::FlatBufferBuilder &_fbb,
10128 flatbuffers::Offset<void> layer = 0) {
10132 return builder_.
Finish();
10135 struct FeatureCompatibilityVersions FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
10137 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10140 VT_CONSTANTTENSORSASINPUTS = 8
10149 return GetField<uint32_t>(VT_CONSTANTTENSORSASINPUTS, 0);
10151 bool Verify(flatbuffers::Verifier &verifier)
const {
10152 return VerifyTableStart(verifier) &&
10155 VerifyField<uint32_t>(verifier, VT_CONSTANTTENSORSASINPUTS) &&
10156 verifier.EndTable();
10171 fbb_.AddElement<uint32_t>(FeatureCompatibilityVersions::VT_CONSTANTTENSORSASINPUTS, constantTensorsAsInputs, 0);
10175 start_ = fbb_.StartTable();
10178 flatbuffers::Offset<FeatureCompatibilityVersions>
Finish() {
10179 const auto end = fbb_.EndTable(start_);
10180 auto o = flatbuffers::Offset<FeatureCompatibilityVersions>(end);
10186 flatbuffers::FlatBufferBuilder &_fbb,
10187 uint32_t bindingIdsScheme = 0,
10188 uint32_t weightsLayoutScheme = 0,
10189 uint32_t constantTensorsAsInputs = 0) {
10194 return builder_.
Finish();
10197 struct SerializedGraph FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
10199 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10203 VT_FEATUREVERSIONS = 10
10205 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::AnyLayer>> *
layers()
const {
10206 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::AnyLayer>> *>(
VT_LAYERS);
10209 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_INPUTIDS);
10212 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_OUTPUTIDS);
10215 return GetPointer<const armnnSerializer::FeatureCompatibilityVersions *>(VT_FEATUREVERSIONS);
10217 bool Verify(flatbuffers::Verifier &verifier)
const {
10218 return VerifyTableStart(verifier) &&
10220 verifier.VerifyVector(layers()) &&
10221 verifier.VerifyVectorOfTables(layers()) &&
10223 verifier.VerifyVector(inputIds()) &&
10225 verifier.VerifyVector(outputIds()) &&
10226 VerifyOffset(verifier, VT_FEATUREVERSIONS) &&
10227 verifier.VerifyTable(featureVersions()) &&
10228 verifier.EndTable();
10246 fbb_.AddOffset(SerializedGraph::VT_FEATUREVERSIONS, featureVersions);
10250 start_ = fbb_.StartTable();
10254 const auto end = fbb_.EndTable(start_);
10255 auto o = flatbuffers::Offset<SerializedGraph>(end);
10261 flatbuffers::FlatBufferBuilder &_fbb,
10262 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::AnyLayer>>> layers = 0,
10265 flatbuffers::Offset<armnnSerializer::FeatureCompatibilityVersions> featureVersions = 0) {
10271 return builder_.
Finish();
10275 flatbuffers::FlatBufferBuilder &_fbb,
10276 const std::vector<flatbuffers::Offset<armnnSerializer::AnyLayer>> *layers =
nullptr,
10277 const std::vector<int32_t> *inputIds =
nullptr,
10278 const std::vector<int32_t> *outputIds =
nullptr,
10279 flatbuffers::Offset<armnnSerializer::FeatureCompatibilityVersions> featureVersions = 0) {
10280 auto layers__ = layers ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::AnyLayer>>(*layers) : 0;
10281 auto inputIds__ = inputIds ? _fbb.CreateVector<int32_t>(*inputIds) : 0;
10282 auto outputIds__ = outputIds ? _fbb.CreateVector<int32_t>(*outputIds) : 0;
10297 auto ptr =
reinterpret_cast<const armnnSerializer::ByteData *
>(obj);
10298 return verifier.VerifyTable(ptr);
10301 auto ptr =
reinterpret_cast<const armnnSerializer::ShortData *
>(obj);
10302 return verifier.VerifyTable(ptr);
10305 auto ptr =
reinterpret_cast<const armnnSerializer::IntData *
>(obj);
10306 return verifier.VerifyTable(ptr);
10309 auto ptr =
reinterpret_cast<const armnnSerializer::LongData *
>(obj);
10310 return verifier.VerifyTable(ptr);
10312 default:
return true;
10316 inline bool VerifyConstTensorDataVector(flatbuffers::Verifier &verifier,
const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
const flatbuffers::Vector<uint8_t> *types) {
10317 if (!values || !types)
return !values && !types;
10318 if (values->size() != types->size())
return false;
10319 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
10334 auto ptr =
reinterpret_cast<const armnnSerializer::ActivationLayer *
>(obj);
10335 return verifier.VerifyTable(ptr);
10338 auto ptr =
reinterpret_cast<const armnnSerializer::AdditionLayer *
>(obj);
10339 return verifier.VerifyTable(ptr);
10342 auto ptr =
reinterpret_cast<const armnnSerializer::BatchToSpaceNdLayer *
>(obj);
10343 return verifier.VerifyTable(ptr);
10346 auto ptr =
reinterpret_cast<const armnnSerializer::BatchNormalizationLayer *
>(obj);
10347 return verifier.VerifyTable(ptr);
10350 auto ptr =
reinterpret_cast<const armnnSerializer::ConstantLayer *
>(obj);
10351 return verifier.VerifyTable(ptr);
10354 auto ptr =
reinterpret_cast<const armnnSerializer::Convolution2dLayer *
>(obj);
10355 return verifier.VerifyTable(ptr);
10358 auto ptr =
reinterpret_cast<const armnnSerializer::DepthwiseConvolution2dLayer *
>(obj);
10359 return verifier.VerifyTable(ptr);
10362 auto ptr =
reinterpret_cast<const armnnSerializer::FullyConnectedLayer *
>(obj);
10363 return verifier.VerifyTable(ptr);
10366 auto ptr =
reinterpret_cast<const armnnSerializer::InputLayer *
>(obj);
10367 return verifier.VerifyTable(ptr);
10370 auto ptr =
reinterpret_cast<const armnnSerializer::MultiplicationLayer *
>(obj);
10371 return verifier.VerifyTable(ptr);
10374 auto ptr =
reinterpret_cast<const armnnSerializer::OutputLayer *
>(obj);
10375 return verifier.VerifyTable(ptr);
10378 auto ptr =
reinterpret_cast<const armnnSerializer::PermuteLayer *
>(obj);
10379 return verifier.VerifyTable(ptr);
10382 auto ptr =
reinterpret_cast<const armnnSerializer::Pooling2dLayer *
>(obj);
10383 return verifier.VerifyTable(ptr);
10386 auto ptr =
reinterpret_cast<const armnnSerializer::ReshapeLayer *
>(obj);
10387 return verifier.VerifyTable(ptr);
10390 auto ptr =
reinterpret_cast<const armnnSerializer::SoftmaxLayer *
>(obj);
10391 return verifier.VerifyTable(ptr);
10394 auto ptr =
reinterpret_cast<const armnnSerializer::SpaceToBatchNdLayer *
>(obj);
10395 return verifier.VerifyTable(ptr);
10398 auto ptr =
reinterpret_cast<const armnnSerializer::DivisionLayer *
>(obj);
10399 return verifier.VerifyTable(ptr);
10402 auto ptr =
reinterpret_cast<const armnnSerializer::MinimumLayer *
>(obj);
10403 return verifier.VerifyTable(ptr);
10406 auto ptr =
reinterpret_cast<const armnnSerializer::EqualLayer *
>(obj);
10407 return verifier.VerifyTable(ptr);
10410 auto ptr =
reinterpret_cast<const armnnSerializer::MaximumLayer *
>(obj);
10411 return verifier.VerifyTable(ptr);
10414 auto ptr =
reinterpret_cast<const armnnSerializer::NormalizationLayer *
>(obj);
10415 return verifier.VerifyTable(ptr);
10418 auto ptr =
reinterpret_cast<const armnnSerializer::PadLayer *
>(obj);
10419 return verifier.VerifyTable(ptr);
10422 auto ptr =
reinterpret_cast<const armnnSerializer::RsqrtLayer *
>(obj);
10423 return verifier.VerifyTable(ptr);
10426 auto ptr =
reinterpret_cast<const armnnSerializer::FloorLayer *
>(obj);
10427 return verifier.VerifyTable(ptr);
10430 auto ptr =
reinterpret_cast<const armnnSerializer::GreaterLayer *
>(obj);
10431 return verifier.VerifyTable(ptr);
10434 auto ptr =
reinterpret_cast<const armnnSerializer::ResizeBilinearLayer *
>(obj);
10435 return verifier.VerifyTable(ptr);
10438 auto ptr =
reinterpret_cast<const armnnSerializer::SubtractionLayer *
>(obj);
10439 return verifier.VerifyTable(ptr);
10442 auto ptr =
reinterpret_cast<const armnnSerializer::StridedSliceLayer *
>(obj);
10443 return verifier.VerifyTable(ptr);
10446 auto ptr =
reinterpret_cast<const armnnSerializer::GatherLayer *
>(obj);
10447 return verifier.VerifyTable(ptr);
10450 auto ptr =
reinterpret_cast<const armnnSerializer::MeanLayer *
>(obj);
10451 return verifier.VerifyTable(ptr);
10455 return verifier.VerifyTable(ptr);
10458 auto ptr =
reinterpret_cast<const armnnSerializer::L2NormalizationLayer *
>(obj);
10459 return verifier.VerifyTable(ptr);
10462 auto ptr =
reinterpret_cast<const armnnSerializer::SplitterLayer *
>(obj);
10463 return verifier.VerifyTable(ptr);
10466 auto ptr =
reinterpret_cast<const armnnSerializer::DetectionPostProcessLayer *
>(obj);
10467 return verifier.VerifyTable(ptr);
10470 auto ptr =
reinterpret_cast<const armnnSerializer::LstmLayer *
>(obj);
10471 return verifier.VerifyTable(ptr);
10474 auto ptr =
reinterpret_cast<const armnnSerializer::QuantizedLstmLayer *
>(obj);
10475 return verifier.VerifyTable(ptr);
10478 auto ptr =
reinterpret_cast<const armnnSerializer::QuantizeLayer *
>(obj);
10479 return verifier.VerifyTable(ptr);
10482 auto ptr =
reinterpret_cast<const armnnSerializer::DequantizeLayer *
>(obj);
10483 return verifier.VerifyTable(ptr);
10486 auto ptr =
reinterpret_cast<const armnnSerializer::MergeLayer *
>(obj);
10487 return verifier.VerifyTable(ptr);
10490 auto ptr =
reinterpret_cast<const armnnSerializer::SwitchLayer *
>(obj);
10491 return verifier.VerifyTable(ptr);
10494 auto ptr =
reinterpret_cast<const armnnSerializer::ConcatLayer *
>(obj);
10495 return verifier.VerifyTable(ptr);
10498 auto ptr =
reinterpret_cast<const armnnSerializer::SpaceToDepthLayer *
>(obj);
10499 return verifier.VerifyTable(ptr);
10502 auto ptr =
reinterpret_cast<const armnnSerializer::PreluLayer *
>(obj);
10503 return verifier.VerifyTable(ptr);
10506 auto ptr =
reinterpret_cast<const armnnSerializer::TransposeConvolution2dLayer *
>(obj);
10507 return verifier.VerifyTable(ptr);
10510 auto ptr =
reinterpret_cast<const armnnSerializer::ResizeLayer *
>(obj);
10511 return verifier.VerifyTable(ptr);
10514 auto ptr =
reinterpret_cast<const armnnSerializer::StackLayer *
>(obj);
10515 return verifier.VerifyTable(ptr);
10518 auto ptr =
reinterpret_cast<const armnnSerializer::AbsLayer *
>(obj);
10519 return verifier.VerifyTable(ptr);
10522 auto ptr =
reinterpret_cast<const armnnSerializer::ArgMinMaxLayer *
>(obj);
10523 return verifier.VerifyTable(ptr);
10526 auto ptr =
reinterpret_cast<const armnnSerializer::SliceLayer *
>(obj);
10527 return verifier.VerifyTable(ptr);
10530 auto ptr =
reinterpret_cast<const armnnSerializer::DepthToSpaceLayer *
>(obj);
10531 return verifier.VerifyTable(ptr);
10534 auto ptr =
reinterpret_cast<const armnnSerializer::InstanceNormalizationLayer *
>(obj);
10535 return verifier.VerifyTable(ptr);
10538 auto ptr =
reinterpret_cast<const armnnSerializer::LogSoftmaxLayer *
>(obj);
10539 return verifier.VerifyTable(ptr);
10542 auto ptr =
reinterpret_cast<const armnnSerializer::ComparisonLayer *
>(obj);
10543 return verifier.VerifyTable(ptr);
10546 auto ptr =
reinterpret_cast<const armnnSerializer::StandInLayer *
>(obj);
10547 return verifier.VerifyTable(ptr);
10550 auto ptr =
reinterpret_cast<const armnnSerializer::ElementwiseUnaryLayer *
>(obj);
10551 return verifier.VerifyTable(ptr);
10554 auto ptr =
reinterpret_cast<const armnnSerializer::TransposeLayer *
>(obj);
10555 return verifier.VerifyTable(ptr);
10558 auto ptr =
reinterpret_cast<const armnnSerializer::QLstmLayer *
>(obj);
10559 return verifier.VerifyTable(ptr);
10562 auto ptr =
reinterpret_cast<const armnnSerializer::FillLayer *
>(obj);
10563 return verifier.VerifyTable(ptr);
10566 auto ptr =
reinterpret_cast<const armnnSerializer::RankLayer *
>(obj);
10567 return verifier.VerifyTable(ptr);
10570 auto ptr =
reinterpret_cast<const armnnSerializer::LogicalBinaryLayer *
>(obj);
10571 return verifier.VerifyTable(ptr);
10574 auto ptr =
reinterpret_cast<const armnnSerializer::ReduceLayer *
>(obj);
10575 return verifier.VerifyTable(ptr);
10578 auto ptr =
reinterpret_cast<const armnnSerializer::CastLayer *
>(obj);
10579 return verifier.VerifyTable(ptr);
10582 auto ptr =
reinterpret_cast<const armnnSerializer::ShapeLayer *
>(obj);
10583 return verifier.VerifyTable(ptr);
10586 auto ptr =
reinterpret_cast<const armnnSerializer::UnidirectionalSequenceLstmLayer *
>(obj);
10587 return verifier.VerifyTable(ptr);
10589 default:
return true;
10593 inline bool VerifyLayerVector(flatbuffers::Verifier &verifier,
const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
const flatbuffers::Vector<uint8_t> *types) {
10594 if (!values || !types)
return !values && !types;
10595 if (values->size() != types->size())
return false;
10596 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
10598 verifier, values->Get(i), types->GetEnum<
Layer>(i))) {
10606 return flatbuffers::GetRoot<armnnSerializer::SerializedGraph>(buf);
10610 return flatbuffers::GetSizePrefixedRoot<armnnSerializer::SerializedGraph>(buf);
10618 return flatbuffers::BufferHasIdentifier(
10623 flatbuffers::Verifier &verifier) {
10628 flatbuffers::Verifier &verifier) {
10637 flatbuffers::FlatBufferBuilder &fbb,
10638 flatbuffers::Offset<armnnSerializer::SerializedGraph> root) {
10643 flatbuffers::FlatBufferBuilder &fbb,
10644 flatbuffers::Offset<armnnSerializer::SerializedGraph> root) {
10650 #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)
flatbuffers::Offset< DepthToSpaceLayer > Finish()
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< 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)
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 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
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
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< SoftmaxDescriptor > CreateSoftmaxDescriptor(flatbuffers::FlatBufferBuilder &_fbb, float beta=0.0f)
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()
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_
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
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
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_
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
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)
const armnnSerializer::MultiplicationLayer * layer_as_MultiplicationLayer() const
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::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_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
const ReduceOperation(& EnumValuesReduceOperation())[4]
flatbuffers::FlatBufferBuilder & fbb_
Convolution2dLayerBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< ConstantLayer > Finish()
VT_RECURRENTTOOUTPUTWEIGHTS
flatbuffers::uoffset_t start_
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_
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
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_
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
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)
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 DataLayout(& EnumValuesDataLayout())[2]
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)
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
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
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_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::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::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)
EqualLayerBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
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)
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::Offset< FeatureCompatibilityVersions > CreateFeatureCompatibilityVersions(flatbuffers::FlatBufferBuilder &_fbb, uint32_t bindingIdsScheme=0, uint32_t weightsLayoutScheme=0, uint32_t constantTensorsAsInputs=0)
const armnnSerializer::ConstTensor * inputToInputWeights() const
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 armnnSerializer::DepthToSpaceDescriptor * descriptor() const
MaximumLayerBuilder Builder
flatbuffers::uoffset_t start_
PadDescriptorBuilder Builder
CastLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::ConstTensor * projectionWeights() const
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::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
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
flatbuffers::Offset< PadDescriptor > CreatePadDescriptor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> padList=0, float padValue=0.0f)
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
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_
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 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
DepthToSpaceLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
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
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()
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< 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)
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
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)
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::Offset< StridedSliceDescriptor > Finish()
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::ConstTensor * inputToForgetWeights() const
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()
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 Layer(& EnumValuesLayer())[65]
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
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)
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)
VT_INPUTINTERMEDIATESCALE
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
const armnnSerializer::ViewsDescriptor * descriptor() const
void add_layer_type(armnnSerializer::Layer layer_type)
StackLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::uoffset_t start_
LogSoftmaxLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
void add_targetHeight(uint32_t targetHeight)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< IntData > CreateIntData(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< int32_t >> data=0)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const armnnSerializer::SliceDescriptor * descriptor() const
ElementwiseUnaryLayer Table
void add_targetShape(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> targetShape)
flatbuffers::Offset< ArgMinMaxDescriptor > Finish()
void add_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)
const LayerType(& EnumValuesLayerType())[64]
flatbuffers::Offset< DequantizeLayer > CreateDequantizeLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
BatchToSpaceNdDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
StackLayerBuilder Builder
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)
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)
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)
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)
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
flatbuffers::Offset< PadDescriptor > CreatePadDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint32_t > *padList=nullptr, float padValue=0.0f)
UnidirectionalSequenceLstmLayerBuilder Builder
armnnSerializer::ConstTensorData data_type() const
void add_descriptor(flatbuffers::Offset< armnnSerializer::PermuteDescriptor > descriptor)
flatbuffers::Offset< StridedSliceDescriptor > CreateStridedSliceDescriptor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< int32_t >> begin=0, flatbuffers::Offset< flatbuffers::Vector< int32_t >> end=0, flatbuffers::Offset< flatbuffers::Vector< int32_t >> stride=0, int32_t beginMask=0, int32_t endMask=0, int32_t shrinkAxisMask=0, int32_t ellipsisMask=0, int32_t newAxisMask=0, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
flatbuffers::Offset< OriginsDescriptor > CreateOriginsDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t concatAxis=0, uint32_t numViews=0, uint32_t numDimensions=0, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::UintVector >>> viewOrigins=0)
flatbuffers::Offset< QLstmLayer > CreateQLstmLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::QLstmDescriptor > descriptor=0, flatbuffers::Offset< armnnSerializer::QLstmInputParams > inputParams=0)
void add_activationFunc(uint32_t activationFunc)
NormalizationAlgorithmMethod
flatbuffers::Offset< RankLayer > Finish()
flatbuffers::uoffset_t start_
void add_axis(int32_t axis)
uint32_t quantizationDim() const
flatbuffers::Offset< ReduceDescriptor > CreateReduceDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, bool keepDims=false, const std::vector< uint32_t > *axis=nullptr, armnnSerializer::ReduceOperation reduceOperation=armnnSerializer::ReduceOperation_Sum)
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::ConstTensor * outputGateBias() const
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< LstmDescriptor > CreateLstmDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t activationFunc=0, float clippingThresCell=0.0f, float clippingThresProj=0.0f, bool cifgEnabled=true, bool peepholeEnabled=false, bool projectionEnabled=false, bool layerNormEnabled=false)
flatbuffers::FlatBufferBuilder & fbb_
const flatbuffers::Vector< uint32_t > * data() const
flatbuffers::Offset< L2NormalizationDescriptor > Finish()
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)
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
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)