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;
65 struct ComparisonDescriptor;
66 struct ComparisonDescriptorBuilder;
68 struct ComparisonLayer;
69 struct ComparisonLayerBuilder;
72 struct ConstantLayerBuilder;
74 struct Convolution2dLayer;
75 struct Convolution2dLayerBuilder;
77 struct Convolution2dDescriptor;
78 struct Convolution2dDescriptorBuilder;
80 struct DepthToSpaceLayer;
81 struct DepthToSpaceLayerBuilder;
84 struct DepthToSpaceDescriptorBuilder;
87 struct DivisionLayerBuilder;
89 struct ElementwiseUnaryDescriptor;
90 struct ElementwiseUnaryDescriptorBuilder;
92 struct ElementwiseUnaryLayer;
93 struct ElementwiseUnaryLayerBuilder;
96 struct EqualLayerBuilder;
99 struct FillLayerBuilder;
101 struct FillDescriptor;
102 struct FillDescriptorBuilder;
105 struct FloorLayerBuilder;
107 struct FullyConnectedLayer;
108 struct FullyConnectedLayerBuilder;
110 struct FullyConnectedDescriptor;
111 struct FullyConnectedDescriptorBuilder;
114 struct GatherLayerBuilder;
116 struct GatherDescriptor;
117 struct GatherDescriptorBuilder;
120 struct GreaterLayerBuilder;
123 struct InputLayerBuilder;
125 struct InstanceNormalizationLayer;
126 struct InstanceNormalizationLayerBuilder;
128 struct InstanceNormalizationDescriptor;
129 struct InstanceNormalizationDescriptorBuilder;
131 struct LogSoftmaxLayer;
132 struct LogSoftmaxLayerBuilder;
135 struct LogSoftmaxDescriptorBuilder;
137 struct L2NormalizationLayer;
138 struct L2NormalizationLayerBuilder;
140 struct L2NormalizationDescriptor;
141 struct L2NormalizationDescriptorBuilder;
143 struct LogicalBinaryDescriptor;
144 struct LogicalBinaryDescriptorBuilder;
146 struct LogicalBinaryLayer;
147 struct LogicalBinaryLayerBuilder;
150 struct MinimumLayerBuilder;
153 struct MaximumLayerBuilder;
155 struct MultiplicationLayer;
156 struct MultiplicationLayerBuilder;
158 struct Pooling2dLayer;
159 struct Pooling2dLayerBuilder;
161 struct Pooling2dDescriptor;
162 struct Pooling2dDescriptorBuilder;
164 struct QuantizeLayer;
165 struct QuantizeLayerBuilder;
168 struct SoftmaxLayerBuilder;
170 struct SoftmaxDescriptor;
171 struct SoftmaxDescriptorBuilder;
173 struct DepthwiseConvolution2dLayer;
174 struct DepthwiseConvolution2dLayerBuilder;
176 struct DepthwiseConvolution2dDescriptor;
177 struct DepthwiseConvolution2dDescriptorBuilder;
180 struct OutputLayerBuilder;
183 struct ReshapeLayerBuilder;
185 struct ReshapeDescriptor;
186 struct ReshapeDescriptorBuilder;
189 struct PermuteLayerBuilder;
191 struct PermuteDescriptor;
192 struct PermuteDescriptorBuilder;
194 struct SpaceToBatchNdLayer;
195 struct SpaceToBatchNdLayerBuilder;
197 struct SpaceToBatchNdDescriptor;
198 struct SpaceToBatchNdDescriptorBuilder;
200 struct SpaceToDepthLayer;
201 struct SpaceToDepthLayerBuilder;
203 struct SpaceToDepthDescriptor;
204 struct SpaceToDepthDescriptorBuilder;
206 struct SubtractionLayer;
207 struct SubtractionLayerBuilder;
209 struct BatchToSpaceNdLayer;
210 struct BatchToSpaceNdLayerBuilder;
212 struct BatchToSpaceNdDescriptor;
213 struct BatchToSpaceNdDescriptorBuilder;
215 struct NormalizationLayer;
216 struct NormalizationLayerBuilder;
218 struct NormalizationDescriptor;
219 struct NormalizationDescriptorBuilder;
222 struct MeanLayerBuilder;
224 struct MeanDescriptor;
225 struct MeanDescriptorBuilder;
228 struct PadLayerBuilder;
230 struct PadDescriptor;
231 struct PadDescriptorBuilder;
234 struct RsqrtLayerBuilder;
236 struct BatchNormalizationLayer;
237 struct BatchNormalizationLayerBuilder;
239 struct BatchNormalizationDescriptor;
240 struct BatchNormalizationDescriptorBuilder;
242 struct ResizeBilinearLayer;
243 struct ResizeBilinearLayerBuilder;
245 struct ResizeBilinearDescriptor;
246 struct ResizeBilinearDescriptorBuilder;
249 struct SliceLayerBuilder;
251 struct SliceDescriptor;
252 struct SliceDescriptorBuilder;
254 struct StridedSliceLayer;
255 struct StridedSliceLayerBuilder;
257 struct StridedSliceDescriptor;
258 struct StridedSliceDescriptorBuilder;
261 struct ConcatLayerBuilder;
264 struct MergerLayerBuilder;
267 struct UintVectorBuilder;
269 struct OriginsDescriptor;
270 struct OriginsDescriptorBuilder;
272 struct ViewsDescriptor;
273 struct ViewsDescriptorBuilder;
275 struct SplitterLayer;
276 struct SplitterLayerBuilder;
278 struct DetectionPostProcessLayer;
279 struct DetectionPostProcessLayerBuilder;
281 struct DetectionPostProcessDescriptor;
282 struct DetectionPostProcessDescriptorBuilder;
284 struct LstmInputParams;
285 struct LstmInputParamsBuilder;
287 struct LstmDescriptor;
288 struct LstmDescriptorBuilder;
291 struct LstmLayerBuilder;
293 struct QLstmInputParams;
294 struct QLstmInputParamsBuilder;
296 struct QLstmDescriptor;
297 struct QLstmDescriptorBuilder;
300 struct QLstmLayerBuilder;
302 struct QuantizedLstmInputParams;
303 struct QuantizedLstmInputParamsBuilder;
305 struct QuantizedLstmLayer;
306 struct QuantizedLstmLayerBuilder;
308 struct DequantizeLayer;
309 struct DequantizeLayerBuilder;
312 struct MergeLayerBuilder;
315 struct SwitchLayerBuilder;
318 struct PreluLayerBuilder;
320 struct TransposeConvolution2dLayer;
321 struct TransposeConvolution2dLayerBuilder;
323 struct TransposeConvolution2dDescriptor;
324 struct TransposeConvolution2dDescriptorBuilder;
326 struct TransposeLayer;
327 struct TransposeLayerBuilder;
329 struct TransposeDescriptor;
330 struct TransposeDescriptorBuilder;
333 struct ResizeLayerBuilder;
335 struct ResizeDescriptor;
336 struct ResizeDescriptorBuilder;
339 struct StackLayerBuilder;
341 struct StackDescriptor;
342 struct StackDescriptorBuilder;
344 struct StandInDescriptor;
345 struct StandInDescriptorBuilder;
348 struct StandInLayerBuilder;
351 struct RankLayerBuilder;
354 struct ReduceLayerBuilder;
356 struct ReduceDescriptor;
357 struct ReduceDescriptorBuilder;
360 struct AnyLayerBuilder;
362 struct FeatureCompatibilityVersions;
363 struct FeatureCompatibilityVersionsBuilder;
365 struct SerializedGraph;
366 struct SerializedGraphBuilder;
404 static const char *
const names[13] = {
424 const size_t index =
static_cast<size_t>(e);
444 static const char *
const names[3] = {
454 const size_t index =
static_cast<size_t>(e);
490 static const char *
const names[11] = {
508 const size_t index =
static_cast<size_t>(e);
528 static const char *
const names[3] = {
538 const size_t index =
static_cast<size_t>(e);
562 static const char *
const names[5] = {
574 const size_t index =
static_cast<size_t>(e);
594 static const char *
const names[3] = {
604 const size_t index =
static_cast<size_t>(e);
630 static const char *
const names[6] = {
643 const size_t index =
static_cast<size_t>(e);
668 bool VerifyConstTensorDataVector(flatbuffers::Verifier &verifier,
const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
const flatbuffers::Vector<uint8_t> *types);
804 static const char *
const names[62] = {
813 "DepthwiseConvolution2d",
828 "BatchNormalization",
838 "DetectionPostProcess",
847 "TransposeConvolution2d",
855 "InstanceNormalization",
873 const size_t index =
static_cast<size_t>(e);
901 static const char *
const names[7] = {
915 const size_t index =
static_cast<size_t>(e);
943 static const char *
const names[7] = {
957 const size_t index =
static_cast<size_t>(e);
977 static const char *
const names[3] = {
987 const size_t index =
static_cast<size_t>(e);
1009 static const char *
const names[4] = {
1020 const size_t index =
static_cast<size_t>(e);
1040 static const char *
const names[3] = {
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);
1212 static const Layer values[] = {
1280 static const char *
const names[63] = {
1284 "BatchToSpaceNdLayer",
1285 "BatchNormalizationLayer",
1287 "Convolution2dLayer",
1288 "DepthwiseConvolution2dLayer",
1289 "FullyConnectedLayer",
1291 "MultiplicationLayer",
1297 "SpaceToBatchNdLayer",
1302 "NormalizationLayer",
1307 "ResizeBilinearLayer",
1309 "StridedSliceLayer",
1313 "L2NormalizationLayer",
1315 "DetectionPostProcessLayer",
1317 "QuantizedLstmLayer",
1323 "SpaceToDepthLayer",
1325 "TransposeConvolution2dLayer",
1331 "DepthToSpaceLayer",
1332 "InstanceNormalizationLayer",
1336 "ElementwiseUnaryLayer",
1341 "LogicalBinaryLayer",
1350 const size_t index =
static_cast<size_t>(e);
1602 bool VerifyLayer(flatbuffers::Verifier &verifier,
const void *obj,
Layer type);
1603 bool VerifyLayerVector(flatbuffers::Verifier &verifier,
const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
const flatbuffers::Vector<uint8_t> *types);
1607 uint32_t sourceLayerIndex_;
1608 uint32_t outputSlotIndex_;
1612 memset(static_cast<void *>(
this), 0,
sizeof(Connection));
1614 Connection(uint32_t _sourceLayerIndex, uint32_t _outputSlotIndex)
1615 : sourceLayerIndex_(flatbuffers::EndianScalar(_sourceLayerIndex)),
1616 outputSlotIndex_(flatbuffers::EndianScalar(_outputSlotIndex)) {
1618 uint32_t sourceLayerIndex()
const {
1619 return flatbuffers::EndianScalar(sourceLayerIndex_);
1621 uint32_t outputSlotIndex()
const {
1622 return flatbuffers::EndianScalar(outputSlotIndex_);
1629 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1637 VT_DIMENSIONSPECIFICITY = 18
1640 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_DIMENSIONS);
1661 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DIMENSIONSPECIFICITY);
1663 bool Verify(flatbuffers::Verifier &verifier)
const {
1664 return VerifyTableStart(verifier) &&
1666 verifier.VerifyVector(dimensions()) &&
1671 verifier.VerifyVector(quantizationScales()) &&
1674 VerifyOffset(verifier, VT_DIMENSIONSPECIFICITY) &&
1675 verifier.VerifyVector(dimensionSpecificity()) &&
1676 verifier.EndTable();
1682 flatbuffers::FlatBufferBuilder &
fbb_;
1706 fbb_.AddOffset(TensorInfo::VT_DIMENSIONSPECIFICITY, dimensionSpecificity);
1710 start_ = fbb_.StartTable();
1714 const auto end = fbb_.EndTable(start_);
1715 auto o = flatbuffers::Offset<TensorInfo>(end);
1721 flatbuffers::FlatBufferBuilder &_fbb,
1724 float quantizationScale = 1.0f,
1725 int32_t quantizationOffset = 0,
1727 uint32_t quantizationDim = 0,
1728 uint32_t dimensionality = 1,
1739 return builder_.
Finish();
1743 flatbuffers::FlatBufferBuilder &_fbb,
1744 const std::vector<uint32_t> *dimensions =
nullptr,
1746 float quantizationScale = 1.0f,
1747 int32_t quantizationOffset = 0,
1748 const std::vector<float> *quantizationScales =
nullptr,
1749 uint32_t quantizationDim = 0,
1750 uint32_t dimensionality = 1,
1751 const std::vector<uint8_t> *dimensionSpecificity =
nullptr) {
1752 auto dimensions__ = dimensions ? _fbb.CreateVector<uint32_t>(*dimensions) : 0;
1753 auto quantizationScales__ = quantizationScales ? _fbb.CreateVector<
float>(*quantizationScales) : 0;
1754 auto dimensionSpecificity__ = dimensionSpecificity ? _fbb.CreateVector<uint8_t>(*dimensionSpecificity) : 0;
1761 quantizationScales__,
1764 dimensionSpecificity__);
1767 struct ByteData FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
1769 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1772 const flatbuffers::Vector<int8_t> *
data()
const {
1773 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_DATA);
1775 bool Verify(flatbuffers::Verifier &verifier)
const {
1776 return VerifyTableStart(verifier) &&
1777 VerifyOffset(verifier, VT_DATA) &&
1778 verifier.VerifyVector(data()) &&
1779 verifier.EndTable();
1785 flatbuffers::FlatBufferBuilder &
fbb_;
1788 fbb_.AddOffset(ByteData::VT_DATA, data);
1792 start_ = fbb_.StartTable();
1796 const auto end = fbb_.EndTable(start_);
1797 auto o = flatbuffers::Offset<ByteData>(end);
1803 flatbuffers::FlatBufferBuilder &_fbb,
1807 return builder_.
Finish();
1811 flatbuffers::FlatBufferBuilder &_fbb,
1812 const std::vector<int8_t> *data =
nullptr) {
1813 auto data__ = data ? _fbb.CreateVector<int8_t>(*data) : 0;
1819 struct ShortData FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
1821 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1824 const flatbuffers::Vector<int16_t> *
data()
const {
1825 return GetPointer<const flatbuffers::Vector<int16_t> *>(VT_DATA);
1827 bool Verify(flatbuffers::Verifier &verifier)
const {
1828 return VerifyTableStart(verifier) &&
1829 VerifyOffset(verifier, VT_DATA) &&
1830 verifier.VerifyVector(data()) &&
1831 verifier.EndTable();
1837 flatbuffers::FlatBufferBuilder &
fbb_;
1840 fbb_.AddOffset(ShortData::VT_DATA, data);
1844 start_ = fbb_.StartTable();
1848 const auto end = fbb_.EndTable(start_);
1849 auto o = flatbuffers::Offset<ShortData>(end);
1855 flatbuffers::FlatBufferBuilder &_fbb,
1859 return builder_.
Finish();
1863 flatbuffers::FlatBufferBuilder &_fbb,
1864 const std::vector<int16_t> *data =
nullptr) {
1865 auto data__ = data ? _fbb.CreateVector<int16_t>(*data) : 0;
1871 struct IntData FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
1873 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1876 const flatbuffers::Vector<int32_t> *
data()
const {
1877 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_DATA);
1879 bool Verify(flatbuffers::Verifier &verifier)
const {
1880 return VerifyTableStart(verifier) &&
1881 VerifyOffset(verifier, VT_DATA) &&
1882 verifier.VerifyVector(data()) &&
1883 verifier.EndTable();
1889 flatbuffers::FlatBufferBuilder &
fbb_;
1892 fbb_.AddOffset(IntData::VT_DATA, data);
1896 start_ = fbb_.StartTable();
1900 const auto end = fbb_.EndTable(start_);
1901 auto o = flatbuffers::Offset<IntData>(end);
1907 flatbuffers::FlatBufferBuilder &_fbb,
1911 return builder_.
Finish();
1915 flatbuffers::FlatBufferBuilder &_fbb,
1916 const std::vector<int32_t> *data =
nullptr) {
1917 auto data__ = data ? _fbb.CreateVector<int32_t>(*data) : 0;
1923 struct LongData FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
1925 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1928 const flatbuffers::Vector<int64_t> *
data()
const {
1929 return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_DATA);
1931 bool Verify(flatbuffers::Verifier &verifier)
const {
1932 return VerifyTableStart(verifier) &&
1933 VerifyOffset(verifier, VT_DATA) &&
1934 verifier.VerifyVector(data()) &&
1935 verifier.EndTable();
1941 flatbuffers::FlatBufferBuilder &
fbb_;
1944 fbb_.AddOffset(LongData::VT_DATA, data);
1948 start_ = fbb_.StartTable();
1952 const auto end = fbb_.EndTable(start_);
1953 auto o = flatbuffers::Offset<LongData>(end);
1959 flatbuffers::FlatBufferBuilder &_fbb,
1963 return builder_.
Finish();
1967 flatbuffers::FlatBufferBuilder &_fbb,
1968 const std::vector<int64_t> *data =
nullptr) {
1969 auto data__ = data ? _fbb.CreateVector<int64_t>(*data) : 0;
1975 struct ConstTensor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
1977 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1982 const armnnSerializer::TensorInfo *
info()
const {
1983 return GetPointer<const armnnSerializer::TensorInfo *>(
VT_INFO);
1989 return GetPointer<const void *>(VT_DATA);
1991 template<
typename T>
const T *data_as()
const;
2004 bool Verify(flatbuffers::Verifier &verifier)
const {
2005 return VerifyTableStart(verifier) &&
2006 VerifyOffset(verifier,
VT_INFO) &&
2007 verifier.VerifyTable(info()) &&
2009 VerifyOffset(verifier, VT_DATA) &&
2011 verifier.EndTable();
2015 template<>
inline const armnnSerializer::ByteData *ConstTensor::data_as<armnnSerializer::ByteData>()
const {
2016 return data_as_ByteData();
2019 template<>
inline const armnnSerializer::ShortData *ConstTensor::data_as<armnnSerializer::ShortData>()
const {
2020 return data_as_ShortData();
2023 template<>
inline const armnnSerializer::IntData *ConstTensor::data_as<armnnSerializer::IntData>()
const {
2024 return data_as_IntData();
2027 template<>
inline const armnnSerializer::LongData *ConstTensor::data_as<armnnSerializer::LongData>()
const {
2028 return data_as_LongData();
2033 flatbuffers::FlatBufferBuilder &
fbb_;
2035 void add_info(flatbuffers::Offset<armnnSerializer::TensorInfo> info) {
2042 fbb_.AddOffset(ConstTensor::VT_DATA, data);
2046 start_ = fbb_.StartTable();
2050 const auto end = fbb_.EndTable(start_);
2051 auto o = flatbuffers::Offset<ConstTensor>(end);
2057 flatbuffers::FlatBufferBuilder &_fbb,
2058 flatbuffers::Offset<armnnSerializer::TensorInfo> info = 0,
2060 flatbuffers::Offset<void> data = 0) {
2065 return builder_.
Finish();
2068 struct InputSlot FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2070 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2075 return GetField<uint32_t>(
VT_INDEX, 0);
2078 return GetStruct<const armnnSerializer::Connection *>(VT_CONNECTION);
2080 bool Verify(flatbuffers::Verifier &verifier)
const {
2081 return VerifyTableStart(verifier) &&
2082 VerifyField<uint32_t>(verifier,
VT_INDEX) &&
2083 VerifyField<armnnSerializer::Connection>(verifier, VT_CONNECTION) &&
2084 verifier.EndTable();
2090 flatbuffers::FlatBufferBuilder &
fbb_;
2096 fbb_.AddStruct(InputSlot::VT_CONNECTION, connection);
2100 start_ = fbb_.StartTable();
2104 const auto end = fbb_.EndTable(start_);
2105 auto o = flatbuffers::Offset<InputSlot>(end);
2111 flatbuffers::FlatBufferBuilder &_fbb,
2113 const armnnSerializer::Connection *connection = 0) {
2117 return builder_.
Finish();
2120 struct OutputSlot FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2122 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2127 return GetField<uint32_t>(
VT_INDEX, 0);
2130 return GetPointer<const armnnSerializer::TensorInfo *>(VT_TENSORINFO);
2132 bool Verify(flatbuffers::Verifier &verifier)
const {
2133 return VerifyTableStart(verifier) &&
2134 VerifyField<uint32_t>(verifier,
VT_INDEX) &&
2135 VerifyOffset(verifier, VT_TENSORINFO) &&
2136 verifier.VerifyTable(tensorInfo()) &&
2137 verifier.EndTable();
2143 flatbuffers::FlatBufferBuilder &
fbb_;
2149 fbb_.AddOffset(OutputSlot::VT_TENSORINFO, tensorInfo);
2153 start_ = fbb_.StartTable();
2157 const auto end = fbb_.EndTable(start_);
2158 auto o = flatbuffers::Offset<OutputSlot>(end);
2164 flatbuffers::FlatBufferBuilder &_fbb,
2166 flatbuffers::Offset<armnnSerializer::TensorInfo> tensorInfo = 0) {
2170 return builder_.
Finish();
2173 struct LayerBase FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2175 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2183 return GetField<uint32_t>(
VT_INDEX, 0);
2186 return GetPointer<const flatbuffers::String *>(
VT_LAYERNAME);
2191 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::InputSlot>> *
inputSlots()
const {
2192 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::InputSlot>> *>(
VT_INPUTSLOTS);
2194 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::OutputSlot>> *
outputSlots()
const {
2195 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::OutputSlot>> *>(VT_OUTPUTSLOTS);
2197 bool Verify(flatbuffers::Verifier &verifier)
const {
2198 return VerifyTableStart(verifier) &&
2199 VerifyField<uint32_t>(verifier,
VT_INDEX) &&
2201 verifier.VerifyString(layerName()) &&
2204 verifier.VerifyVector(inputSlots()) &&
2205 verifier.VerifyVectorOfTables(inputSlots()) &&
2206 VerifyOffset(verifier, VT_OUTPUTSLOTS) &&
2207 verifier.VerifyVector(outputSlots()) &&
2208 verifier.VerifyVectorOfTables(outputSlots()) &&
2209 verifier.EndTable();
2215 flatbuffers::FlatBufferBuilder &
fbb_;
2230 fbb_.AddOffset(LayerBase::VT_OUTPUTSLOTS, outputSlots);
2234 start_ = fbb_.StartTable();
2238 const auto end = fbb_.EndTable(start_);
2239 auto o = flatbuffers::Offset<LayerBase>(end);
2245 flatbuffers::FlatBufferBuilder &_fbb,
2247 flatbuffers::Offset<flatbuffers::String> layerName = 0,
2249 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::InputSlot>>> inputSlots = 0,
2250 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::OutputSlot>>> outputSlots = 0) {
2257 return builder_.
Finish();
2261 flatbuffers::FlatBufferBuilder &_fbb,
2263 const char *layerName =
nullptr,
2265 const std::vector<flatbuffers::Offset<armnnSerializer::InputSlot>> *inputSlots =
nullptr,
2266 const std::vector<flatbuffers::Offset<armnnSerializer::OutputSlot>> *outputSlots =
nullptr) {
2267 auto layerName__ = layerName ? _fbb.CreateString(layerName) : 0;
2268 auto inputSlots__ = inputSlots ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::InputSlot>>(*inputSlots) : 0;
2269 auto outputSlots__ = outputSlots ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::OutputSlot>>(*outputSlots) : 0;
2279 struct BindableLayerBase FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2281 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2283 VT_LAYERBINDINGID = 6
2285 const armnnSerializer::LayerBase *
base()
const {
2286 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2289 return GetField<int32_t>(VT_LAYERBINDINGID, 0);
2291 bool Verify(flatbuffers::Verifier &verifier)
const {
2292 return VerifyTableStart(verifier) &&
2293 VerifyOffset(verifier,
VT_BASE) &&
2294 verifier.VerifyTable(base()) &&
2295 VerifyField<int32_t>(verifier, VT_LAYERBINDINGID) &&
2296 verifier.EndTable();
2302 flatbuffers::FlatBufferBuilder &
fbb_;
2304 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2308 fbb_.AddElement<int32_t>(BindableLayerBase::VT_LAYERBINDINGID, layerBindingId, 0);
2312 start_ = fbb_.StartTable();
2315 flatbuffers::Offset<BindableLayerBase>
Finish() {
2316 const auto end = fbb_.EndTable(start_);
2317 auto o = flatbuffers::Offset<BindableLayerBase>(end);
2323 flatbuffers::FlatBufferBuilder &_fbb,
2324 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2325 int32_t layerBindingId = 0) {
2329 return builder_.
Finish();
2333 struct AbsLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2335 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2338 const armnnSerializer::LayerBase *
base()
const {
2339 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2341 bool Verify(flatbuffers::Verifier &verifier)
const {
2342 return VerifyTableStart(verifier) &&
2343 VerifyOffset(verifier,
VT_BASE) &&
2344 verifier.VerifyTable(base()) &&
2345 verifier.EndTable();
2351 flatbuffers::FlatBufferBuilder &
fbb_;
2353 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2358 start_ = fbb_.StartTable();
2362 const auto end = fbb_.EndTable(start_);
2363 auto o = flatbuffers::Offset<AbsLayer>(end);
2369 flatbuffers::FlatBufferBuilder &_fbb,
2370 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
2373 return builder_.
Finish();
2376 struct ActivationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2378 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2382 const armnnSerializer::LayerBase *
base()
const {
2383 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2385 const armnnSerializer::ActivationDescriptor *
descriptor()
const {
2386 return GetPointer<const armnnSerializer::ActivationDescriptor *>(
VT_DESCRIPTOR);
2388 bool Verify(flatbuffers::Verifier &verifier)
const {
2389 return VerifyTableStart(verifier) &&
2390 VerifyOffset(verifier,
VT_BASE) &&
2391 verifier.VerifyTable(base()) &&
2393 verifier.VerifyTable(descriptor()) &&
2394 verifier.EndTable();
2400 flatbuffers::FlatBufferBuilder &
fbb_;
2402 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2405 void add_descriptor(flatbuffers::Offset<armnnSerializer::ActivationDescriptor> descriptor) {
2410 start_ = fbb_.StartTable();
2413 flatbuffers::Offset<ActivationLayer>
Finish() {
2414 const auto end = fbb_.EndTable(start_);
2415 auto o = flatbuffers::Offset<ActivationLayer>(end);
2421 flatbuffers::FlatBufferBuilder &_fbb,
2422 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2423 flatbuffers::Offset<armnnSerializer::ActivationDescriptor> descriptor = 0) {
2427 return builder_.
Finish();
2430 struct ActivationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2432 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2441 return GetField<float>(
VT_A, 0.0f);
2444 return GetField<float>(VT_B, 0.0f);
2446 bool Verify(flatbuffers::Verifier &verifier)
const {
2447 return VerifyTableStart(verifier) &&
2449 VerifyField<float>(verifier,
VT_A) &&
2450 VerifyField<float>(verifier, VT_B) &&
2451 verifier.EndTable();
2457 flatbuffers::FlatBufferBuilder &
fbb_;
2466 fbb_.AddElement<
float>(ActivationDescriptor::VT_B, b, 0.0f);
2470 start_ = fbb_.StartTable();
2473 flatbuffers::Offset<ActivationDescriptor>
Finish() {
2474 const auto end = fbb_.EndTable(start_);
2475 auto o = flatbuffers::Offset<ActivationDescriptor>(end);
2481 flatbuffers::FlatBufferBuilder &_fbb,
2489 return builder_.
Finish();
2492 struct AdditionLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2494 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2497 const armnnSerializer::LayerBase *
base()
const {
2498 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2500 bool Verify(flatbuffers::Verifier &verifier)
const {
2501 return VerifyTableStart(verifier) &&
2502 VerifyOffset(verifier,
VT_BASE) &&
2503 verifier.VerifyTable(base()) &&
2504 verifier.EndTable();
2510 flatbuffers::FlatBufferBuilder &
fbb_;
2512 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2517 start_ = fbb_.StartTable();
2520 flatbuffers::Offset<AdditionLayer>
Finish() {
2521 const auto end = fbb_.EndTable(start_);
2522 auto o = flatbuffers::Offset<AdditionLayer>(end);
2528 flatbuffers::FlatBufferBuilder &_fbb,
2529 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
2532 return builder_.
Finish();
2535 struct ArgMinMaxLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2537 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2541 const armnnSerializer::LayerBase *
base()
const {
2542 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2545 return GetPointer<const armnnSerializer::ArgMinMaxDescriptor *>(
VT_DESCRIPTOR);
2547 bool Verify(flatbuffers::Verifier &verifier)
const {
2548 return VerifyTableStart(verifier) &&
2549 VerifyOffset(verifier,
VT_BASE) &&
2550 verifier.VerifyTable(base()) &&
2552 verifier.VerifyTable(descriptor()) &&
2553 verifier.EndTable();
2559 flatbuffers::FlatBufferBuilder &
fbb_;
2561 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2564 void add_descriptor(flatbuffers::Offset<armnnSerializer::ArgMinMaxDescriptor> descriptor) {
2569 start_ = fbb_.StartTable();
2572 flatbuffers::Offset<ArgMinMaxLayer>
Finish() {
2573 const auto end = fbb_.EndTable(start_);
2574 auto o = flatbuffers::Offset<ArgMinMaxLayer>(end);
2580 flatbuffers::FlatBufferBuilder &_fbb,
2581 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2582 flatbuffers::Offset<armnnSerializer::ArgMinMaxDescriptor> descriptor = 0) {
2586 return builder_.
Finish();
2589 struct ArgMinMaxDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2591 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2599 return GetField<int32_t>(
VT_AXIS, 0);
2601 bool Verify(flatbuffers::Verifier &verifier)
const {
2602 return VerifyTableStart(verifier) &&
2604 VerifyField<int32_t>(verifier,
VT_AXIS) &&
2605 verifier.EndTable();
2611 flatbuffers::FlatBufferBuilder &
fbb_;
2621 start_ = fbb_.StartTable();
2624 flatbuffers::Offset<ArgMinMaxDescriptor>
Finish() {
2625 const auto end = fbb_.EndTable(start_);
2626 auto o = flatbuffers::Offset<ArgMinMaxDescriptor>(end);
2632 flatbuffers::FlatBufferBuilder &_fbb,
2638 return builder_.
Finish();
2641 struct ComparisonDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2643 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2649 bool Verify(flatbuffers::Verifier &verifier)
const {
2650 return VerifyTableStart(verifier) &&
2651 VerifyField<int8_t>(verifier, VT_OPERATION) &&
2652 verifier.EndTable();
2658 flatbuffers::FlatBufferBuilder &
fbb_;
2661 fbb_.AddElement<int8_t>(ComparisonDescriptor::VT_OPERATION,
static_cast<int8_t
>(operation), 0);
2665 start_ = fbb_.StartTable();
2668 flatbuffers::Offset<ComparisonDescriptor>
Finish() {
2669 const auto end = fbb_.EndTable(start_);
2670 auto o = flatbuffers::Offset<ComparisonDescriptor>(end);
2676 flatbuffers::FlatBufferBuilder &_fbb,
2680 return builder_.
Finish();
2683 struct ComparisonLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2685 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2689 const armnnSerializer::LayerBase *
base()
const {
2690 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2692 const armnnSerializer::ComparisonDescriptor *
descriptor()
const {
2693 return GetPointer<const armnnSerializer::ComparisonDescriptor *>(
VT_DESCRIPTOR);
2695 bool Verify(flatbuffers::Verifier &verifier)
const {
2696 return VerifyTableStart(verifier) &&
2697 VerifyOffset(verifier,
VT_BASE) &&
2698 verifier.VerifyTable(base()) &&
2700 verifier.VerifyTable(descriptor()) &&
2701 verifier.EndTable();
2707 flatbuffers::FlatBufferBuilder &
fbb_;
2709 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2712 void add_descriptor(flatbuffers::Offset<armnnSerializer::ComparisonDescriptor> descriptor) {
2717 start_ = fbb_.StartTable();
2720 flatbuffers::Offset<ComparisonLayer>
Finish() {
2721 const auto end = fbb_.EndTable(start_);
2722 auto o = flatbuffers::Offset<ComparisonLayer>(end);
2728 flatbuffers::FlatBufferBuilder &_fbb,
2729 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2730 flatbuffers::Offset<armnnSerializer::ComparisonDescriptor> descriptor = 0) {
2734 return builder_.
Finish();
2737 struct ConstantLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2739 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2743 const armnnSerializer::LayerBase *
base()
const {
2744 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2746 const armnnSerializer::ConstTensor *
input()
const {
2747 return GetPointer<const armnnSerializer::ConstTensor *>(VT_INPUT);
2749 bool Verify(flatbuffers::Verifier &verifier)
const {
2750 return VerifyTableStart(verifier) &&
2751 VerifyOffset(verifier,
VT_BASE) &&
2752 verifier.VerifyTable(base()) &&
2753 VerifyOffset(verifier, VT_INPUT) &&
2754 verifier.VerifyTable(input()) &&
2755 verifier.EndTable();
2761 flatbuffers::FlatBufferBuilder &
fbb_;
2763 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2766 void add_input(flatbuffers::Offset<armnnSerializer::ConstTensor> input) {
2767 fbb_.AddOffset(ConstantLayer::VT_INPUT, input);
2771 start_ = fbb_.StartTable();
2774 flatbuffers::Offset<ConstantLayer>
Finish() {
2775 const auto end = fbb_.EndTable(start_);
2776 auto o = flatbuffers::Offset<ConstantLayer>(end);
2782 flatbuffers::FlatBufferBuilder &_fbb,
2783 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2784 flatbuffers::Offset<armnnSerializer::ConstTensor> input = 0) {
2788 return builder_.
Finish();
2791 struct Convolution2dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2793 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2799 const armnnSerializer::LayerBase *
base()
const {
2800 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2802 const armnnSerializer::Convolution2dDescriptor *
descriptor()
const {
2803 return GetPointer<const armnnSerializer::Convolution2dDescriptor *>(
VT_DESCRIPTOR);
2805 const armnnSerializer::ConstTensor *
weights()
const {
2806 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_WEIGHTS);
2808 const armnnSerializer::ConstTensor *
biases()
const {
2809 return GetPointer<const armnnSerializer::ConstTensor *>(VT_BIASES);
2811 bool Verify(flatbuffers::Verifier &verifier)
const {
2812 return VerifyTableStart(verifier) &&
2813 VerifyOffset(verifier,
VT_BASE) &&
2814 verifier.VerifyTable(base()) &&
2816 verifier.VerifyTable(descriptor()) &&
2818 verifier.VerifyTable(weights()) &&
2819 VerifyOffset(verifier, VT_BIASES) &&
2820 verifier.VerifyTable(biases()) &&
2821 verifier.EndTable();
2827 flatbuffers::FlatBufferBuilder &
fbb_;
2829 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2832 void add_descriptor(flatbuffers::Offset<armnnSerializer::Convolution2dDescriptor> descriptor) {
2835 void add_weights(flatbuffers::Offset<armnnSerializer::ConstTensor> weights) {
2838 void add_biases(flatbuffers::Offset<armnnSerializer::ConstTensor> biases) {
2839 fbb_.AddOffset(Convolution2dLayer::VT_BIASES, biases);
2843 start_ = fbb_.StartTable();
2846 flatbuffers::Offset<Convolution2dLayer>
Finish() {
2847 const auto end = fbb_.EndTable(start_);
2848 auto o = flatbuffers::Offset<Convolution2dLayer>(end);
2854 flatbuffers::FlatBufferBuilder &_fbb,
2855 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2856 flatbuffers::Offset<armnnSerializer::Convolution2dDescriptor> descriptor = 0,
2857 flatbuffers::Offset<armnnSerializer::ConstTensor> weights = 0,
2858 flatbuffers::Offset<armnnSerializer::ConstTensor> biases = 0) {
2864 return builder_.
Finish();
2867 struct Convolution2dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2869 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2888 return GetField<uint32_t>(
VT_PADTOP, 0);
2911 bool Verify(flatbuffers::Verifier &verifier)
const {
2912 return VerifyTableStart(verifier) &&
2913 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
2915 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
2917 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
2918 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
2923 verifier.EndTable();
2929 flatbuffers::FlatBufferBuilder &
fbb_;
2963 start_ = fbb_.StartTable();
2966 flatbuffers::Offset<Convolution2dDescriptor>
Finish() {
2967 const auto end = fbb_.EndTable(start_);
2968 auto o = flatbuffers::Offset<Convolution2dDescriptor>(end);
2974 flatbuffers::FlatBufferBuilder &_fbb,
2975 uint32_t padLeft = 0,
2976 uint32_t padRight = 0,
2977 uint32_t padTop = 0,
2978 uint32_t padBottom = 0,
2979 uint32_t strideX = 0,
2980 uint32_t strideY = 0,
2981 uint32_t dilationX = 1,
2982 uint32_t dilationY = 1,
2983 bool biasEnabled =
false,
2996 return builder_.
Finish();
2999 struct DepthToSpaceLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3001 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3005 const armnnSerializer::LayerBase *
base()
const {
3006 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3009 return GetPointer<const armnnSerializer::DepthToSpaceDescriptor *>(
VT_DESCRIPTOR);
3011 bool Verify(flatbuffers::Verifier &verifier)
const {
3012 return VerifyTableStart(verifier) &&
3013 VerifyOffset(verifier,
VT_BASE) &&
3014 verifier.VerifyTable(base()) &&
3016 verifier.VerifyTable(descriptor()) &&
3017 verifier.EndTable();
3023 flatbuffers::FlatBufferBuilder &
fbb_;
3025 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3028 void add_descriptor(flatbuffers::Offset<armnnSerializer::DepthToSpaceDescriptor> descriptor) {
3033 start_ = fbb_.StartTable();
3036 flatbuffers::Offset<DepthToSpaceLayer>
Finish() {
3037 const auto end = fbb_.EndTable(start_);
3038 auto o = flatbuffers::Offset<DepthToSpaceLayer>(end);
3044 flatbuffers::FlatBufferBuilder &_fbb,
3045 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3046 flatbuffers::Offset<armnnSerializer::DepthToSpaceDescriptor> descriptor = 0) {
3050 return builder_.
Finish();
3055 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3065 bool Verify(flatbuffers::Verifier &verifier)
const {
3066 return VerifyTableStart(verifier) &&
3069 verifier.EndTable();
3075 flatbuffers::FlatBufferBuilder &
fbb_;
3085 start_ = fbb_.StartTable();
3088 flatbuffers::Offset<DepthToSpaceDescriptor>
Finish() {
3089 const auto end = fbb_.EndTable(start_);
3090 auto o = flatbuffers::Offset<DepthToSpaceDescriptor>(end);
3096 flatbuffers::FlatBufferBuilder &_fbb,
3097 uint32_t blockSize = 0,
3102 return builder_.
Finish();
3105 struct DivisionLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3107 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3110 const armnnSerializer::LayerBase *
base()
const {
3111 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3113 bool Verify(flatbuffers::Verifier &verifier)
const {
3114 return VerifyTableStart(verifier) &&
3115 VerifyOffset(verifier,
VT_BASE) &&
3116 verifier.VerifyTable(base()) &&
3117 verifier.EndTable();
3123 flatbuffers::FlatBufferBuilder &
fbb_;
3125 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3130 start_ = fbb_.StartTable();
3133 flatbuffers::Offset<DivisionLayer>
Finish() {
3134 const auto end = fbb_.EndTable(start_);
3135 auto o = flatbuffers::Offset<DivisionLayer>(end);
3141 flatbuffers::FlatBufferBuilder &_fbb,
3142 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
3145 return builder_.
Finish();
3148 struct ElementwiseUnaryDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3150 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3156 bool Verify(flatbuffers::Verifier &verifier)
const {
3157 return VerifyTableStart(verifier) &&
3158 VerifyField<int8_t>(verifier, VT_OPERATION) &&
3159 verifier.EndTable();
3164 typedef ElementwiseUnaryDescriptor
Table;
3165 flatbuffers::FlatBufferBuilder &
fbb_;
3168 fbb_.AddElement<int8_t>(ElementwiseUnaryDescriptor::VT_OPERATION,
static_cast<int8_t
>(operation), 0);
3172 start_ = fbb_.StartTable();
3175 flatbuffers::Offset<ElementwiseUnaryDescriptor>
Finish() {
3176 const auto end = fbb_.EndTable(start_);
3177 auto o = flatbuffers::Offset<ElementwiseUnaryDescriptor>(end);
3183 flatbuffers::FlatBufferBuilder &_fbb,
3187 return builder_.
Finish();
3190 struct ElementwiseUnaryLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3192 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3196 const armnnSerializer::LayerBase *
base()
const {
3197 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3199 const armnnSerializer::ElementwiseUnaryDescriptor *
descriptor()
const {
3200 return GetPointer<const armnnSerializer::ElementwiseUnaryDescriptor *>(
VT_DESCRIPTOR);
3202 bool Verify(flatbuffers::Verifier &verifier)
const {
3203 return VerifyTableStart(verifier) &&
3204 VerifyOffset(verifier,
VT_BASE) &&
3205 verifier.VerifyTable(base()) &&
3207 verifier.VerifyTable(descriptor()) &&
3208 verifier.EndTable();
3214 flatbuffers::FlatBufferBuilder &
fbb_;
3216 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3219 void add_descriptor(flatbuffers::Offset<armnnSerializer::ElementwiseUnaryDescriptor> descriptor) {
3224 start_ = fbb_.StartTable();
3227 flatbuffers::Offset<ElementwiseUnaryLayer>
Finish() {
3228 const auto end = fbb_.EndTable(start_);
3229 auto o = flatbuffers::Offset<ElementwiseUnaryLayer>(end);
3235 flatbuffers::FlatBufferBuilder &_fbb,
3236 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3237 flatbuffers::Offset<armnnSerializer::ElementwiseUnaryDescriptor> descriptor = 0) {
3241 return builder_.
Finish();
3245 struct EqualLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3247 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3250 const armnnSerializer::LayerBase *
base()
const {
3251 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3253 bool Verify(flatbuffers::Verifier &verifier)
const {
3254 return VerifyTableStart(verifier) &&
3255 VerifyOffset(verifier,
VT_BASE) &&
3256 verifier.VerifyTable(base()) &&
3257 verifier.EndTable();
3263 flatbuffers::FlatBufferBuilder &
fbb_;
3265 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3270 start_ = fbb_.StartTable();
3274 const auto end = fbb_.EndTable(start_);
3275 auto o = flatbuffers::Offset<EqualLayer>(end);
3281 flatbuffers::FlatBufferBuilder &_fbb,
3282 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
3285 return builder_.
Finish();
3288 struct FillLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3290 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3294 const armnnSerializer::LayerBase *
base()
const {
3295 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3298 return GetPointer<const armnnSerializer::FillDescriptor *>(
VT_DESCRIPTOR);
3300 bool Verify(flatbuffers::Verifier &verifier)
const {
3301 return VerifyTableStart(verifier) &&
3302 VerifyOffset(verifier,
VT_BASE) &&
3303 verifier.VerifyTable(base()) &&
3305 verifier.VerifyTable(descriptor()) &&
3306 verifier.EndTable();
3312 flatbuffers::FlatBufferBuilder &
fbb_;
3314 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3317 void add_descriptor(flatbuffers::Offset<armnnSerializer::FillDescriptor> descriptor) {
3322 start_ = fbb_.StartTable();
3326 const auto end = fbb_.EndTable(start_);
3327 auto o = flatbuffers::Offset<FillLayer>(end);
3333 flatbuffers::FlatBufferBuilder &_fbb,
3334 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3335 flatbuffers::Offset<armnnSerializer::FillDescriptor> descriptor = 0) {
3339 return builder_.
Finish();
3342 struct FillDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3344 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3348 return GetField<float>(VT_VALUE, 0.0f);
3350 bool Verify(flatbuffers::Verifier &verifier)
const {
3351 return VerifyTableStart(verifier) &&
3352 VerifyField<float>(verifier, VT_VALUE) &&
3353 verifier.EndTable();
3359 flatbuffers::FlatBufferBuilder &
fbb_;
3362 fbb_.AddElement<
float>(FillDescriptor::VT_VALUE, value, 0.0f);
3366 start_ = fbb_.StartTable();
3369 flatbuffers::Offset<FillDescriptor>
Finish() {
3370 const auto end = fbb_.EndTable(start_);
3371 auto o = flatbuffers::Offset<FillDescriptor>(end);
3377 flatbuffers::FlatBufferBuilder &_fbb,
3378 float value = 0.0f) {
3381 return builder_.
Finish();
3384 struct FloorLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3386 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3389 const armnnSerializer::LayerBase *
base()
const {
3390 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3392 bool Verify(flatbuffers::Verifier &verifier)
const {
3393 return VerifyTableStart(verifier) &&
3394 VerifyOffset(verifier,
VT_BASE) &&
3395 verifier.VerifyTable(base()) &&
3396 verifier.EndTable();
3402 flatbuffers::FlatBufferBuilder &
fbb_;
3404 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3409 start_ = fbb_.StartTable();
3413 const auto end = fbb_.EndTable(start_);
3414 auto o = flatbuffers::Offset<FloorLayer>(end);
3420 flatbuffers::FlatBufferBuilder &_fbb,
3421 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
3424 return builder_.
Finish();
3427 struct FullyConnectedLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3429 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3435 const armnnSerializer::LayerBase *
base()
const {
3436 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3438 const armnnSerializer::FullyConnectedDescriptor *
descriptor()
const {
3439 return GetPointer<const armnnSerializer::FullyConnectedDescriptor *>(
VT_DESCRIPTOR);
3441 const armnnSerializer::ConstTensor *
weights()
const {
3442 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_WEIGHTS);
3444 const armnnSerializer::ConstTensor *
biases()
const {
3445 return GetPointer<const armnnSerializer::ConstTensor *>(VT_BIASES);
3447 bool Verify(flatbuffers::Verifier &verifier)
const {
3448 return VerifyTableStart(verifier) &&
3449 VerifyOffset(verifier,
VT_BASE) &&
3450 verifier.VerifyTable(base()) &&
3452 verifier.VerifyTable(descriptor()) &&
3454 verifier.VerifyTable(weights()) &&
3455 VerifyOffset(verifier, VT_BIASES) &&
3456 verifier.VerifyTable(biases()) &&
3457 verifier.EndTable();
3463 flatbuffers::FlatBufferBuilder &
fbb_;
3465 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3468 void add_descriptor(flatbuffers::Offset<armnnSerializer::FullyConnectedDescriptor> descriptor) {
3471 void add_weights(flatbuffers::Offset<armnnSerializer::ConstTensor> weights) {
3474 void add_biases(flatbuffers::Offset<armnnSerializer::ConstTensor> biases) {
3475 fbb_.AddOffset(FullyConnectedLayer::VT_BIASES, biases);
3479 start_ = fbb_.StartTable();
3482 flatbuffers::Offset<FullyConnectedLayer>
Finish() {
3483 const auto end = fbb_.EndTable(start_);
3484 auto o = flatbuffers::Offset<FullyConnectedLayer>(end);
3490 flatbuffers::FlatBufferBuilder &_fbb,
3491 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3492 flatbuffers::Offset<armnnSerializer::FullyConnectedDescriptor> descriptor = 0,
3493 flatbuffers::Offset<armnnSerializer::ConstTensor> weights = 0,
3494 flatbuffers::Offset<armnnSerializer::ConstTensor> biases = 0) {
3500 return builder_.
Finish();
3503 struct FullyConnectedDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3505 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3507 VT_TRANSPOSEWEIGHTSMATRIX = 6
3513 return GetField<uint8_t>(VT_TRANSPOSEWEIGHTSMATRIX, 0) != 0;
3515 bool Verify(flatbuffers::Verifier &verifier)
const {
3516 return VerifyTableStart(verifier) &&
3518 VerifyField<uint8_t>(verifier, VT_TRANSPOSEWEIGHTSMATRIX) &&
3519 verifier.EndTable();
3525 flatbuffers::FlatBufferBuilder &
fbb_;
3531 fbb_.AddElement<uint8_t>(FullyConnectedDescriptor::VT_TRANSPOSEWEIGHTSMATRIX,
static_cast<uint8_t
>(transposeWeightsMatrix), 0);
3535 start_ = fbb_.StartTable();
3538 flatbuffers::Offset<FullyConnectedDescriptor>
Finish() {
3539 const auto end = fbb_.EndTable(start_);
3540 auto o = flatbuffers::Offset<FullyConnectedDescriptor>(end);
3546 flatbuffers::FlatBufferBuilder &_fbb,
3547 bool biasEnabled =
false,
3548 bool transposeWeightsMatrix =
false) {
3552 return builder_.
Finish();
3555 struct GatherLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3557 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3561 const armnnSerializer::LayerBase *
base()
const {
3562 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3565 return GetPointer<const armnnSerializer::GatherDescriptor *>(
VT_DESCRIPTOR);
3567 bool Verify(flatbuffers::Verifier &verifier)
const {
3568 return VerifyTableStart(verifier) &&
3569 VerifyOffset(verifier,
VT_BASE) &&
3570 verifier.VerifyTable(base()) &&
3572 verifier.VerifyTable(descriptor()) &&
3573 verifier.EndTable();
3579 flatbuffers::FlatBufferBuilder &
fbb_;
3581 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3584 void add_descriptor(flatbuffers::Offset<armnnSerializer::GatherDescriptor> descriptor) {
3589 start_ = fbb_.StartTable();
3593 const auto end = fbb_.EndTable(start_);
3594 auto o = flatbuffers::Offset<GatherLayer>(end);
3600 flatbuffers::FlatBufferBuilder &_fbb,
3601 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3602 flatbuffers::Offset<armnnSerializer::GatherDescriptor> descriptor = 0) {
3606 return builder_.
Finish();
3609 struct GatherDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3611 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3615 return GetField<int32_t>(
VT_AXIS, 0);
3617 bool Verify(flatbuffers::Verifier &verifier)
const {
3618 return VerifyTableStart(verifier) &&
3619 VerifyField<int32_t>(verifier,
VT_AXIS) &&
3620 verifier.EndTable();
3626 flatbuffers::FlatBufferBuilder &
fbb_;
3633 start_ = fbb_.StartTable();
3636 flatbuffers::Offset<GatherDescriptor>
Finish() {
3637 const auto end = fbb_.EndTable(start_);
3638 auto o = flatbuffers::Offset<GatherDescriptor>(end);
3644 flatbuffers::FlatBufferBuilder &_fbb,
3648 return builder_.
Finish();
3652 struct GreaterLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3654 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3657 const armnnSerializer::LayerBase *
base()
const {
3658 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3660 bool Verify(flatbuffers::Verifier &verifier)
const {
3661 return VerifyTableStart(verifier) &&
3662 VerifyOffset(verifier,
VT_BASE) &&
3663 verifier.VerifyTable(base()) &&
3664 verifier.EndTable();
3670 flatbuffers::FlatBufferBuilder &
fbb_;
3672 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3677 start_ = fbb_.StartTable();
3681 const auto end = fbb_.EndTable(start_);
3682 auto o = flatbuffers::Offset<GreaterLayer>(end);
3688 flatbuffers::FlatBufferBuilder &_fbb,
3689 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
3692 return builder_.
Finish();
3695 struct InputLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3697 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3700 const armnnSerializer::BindableLayerBase *
base()
const {
3701 return GetPointer<const armnnSerializer::BindableLayerBase *>(
VT_BASE);
3703 bool Verify(flatbuffers::Verifier &verifier)
const {
3704 return VerifyTableStart(verifier) &&
3705 VerifyOffset(verifier,
VT_BASE) &&
3706 verifier.VerifyTable(base()) &&
3707 verifier.EndTable();
3713 flatbuffers::FlatBufferBuilder &
fbb_;
3715 void add_base(flatbuffers::Offset<armnnSerializer::BindableLayerBase> base) {
3720 start_ = fbb_.StartTable();
3724 const auto end = fbb_.EndTable(start_);
3725 auto o = flatbuffers::Offset<InputLayer>(end);
3731 flatbuffers::FlatBufferBuilder &_fbb,
3732 flatbuffers::Offset<armnnSerializer::BindableLayerBase> base = 0) {
3735 return builder_.
Finish();
3738 struct InstanceNormalizationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3740 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3744 const armnnSerializer::LayerBase *
base()
const {
3745 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3747 const armnnSerializer::InstanceNormalizationDescriptor *
descriptor()
const {
3748 return GetPointer<const armnnSerializer::InstanceNormalizationDescriptor *>(
VT_DESCRIPTOR);
3750 bool Verify(flatbuffers::Verifier &verifier)
const {
3751 return VerifyTableStart(verifier) &&
3752 VerifyOffset(verifier,
VT_BASE) &&
3753 verifier.VerifyTable(base()) &&
3755 verifier.VerifyTable(descriptor()) &&
3756 verifier.EndTable();
3761 typedef InstanceNormalizationLayer
Table;
3762 flatbuffers::FlatBufferBuilder &
fbb_;
3764 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3767 void add_descriptor(flatbuffers::Offset<armnnSerializer::InstanceNormalizationDescriptor> descriptor) {
3772 start_ = fbb_.StartTable();
3775 flatbuffers::Offset<InstanceNormalizationLayer>
Finish() {
3776 const auto end = fbb_.EndTable(start_);
3777 auto o = flatbuffers::Offset<InstanceNormalizationLayer>(end);
3783 flatbuffers::FlatBufferBuilder &_fbb,
3784 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3785 flatbuffers::Offset<armnnSerializer::InstanceNormalizationDescriptor> descriptor = 0) {
3789 return builder_.
Finish();
3792 struct InstanceNormalizationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3794 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3801 return GetField<float>(
VT_GAMMA, 0.0f);
3804 return GetField<float>(
VT_BETA, 0.0f);
3807 return GetField<float>(
VT_EPS, 0.0f);
3812 bool Verify(flatbuffers::Verifier &verifier)
const {
3813 return VerifyTableStart(verifier) &&
3814 VerifyField<float>(verifier,
VT_GAMMA) &&
3815 VerifyField<float>(verifier,
VT_BETA) &&
3816 VerifyField<float>(verifier,
VT_EPS) &&
3818 verifier.EndTable();
3823 typedef InstanceNormalizationDescriptor
Table;
3824 flatbuffers::FlatBufferBuilder &
fbb_;
3840 start_ = fbb_.StartTable();
3843 flatbuffers::Offset<InstanceNormalizationDescriptor>
Finish() {
3844 const auto end = fbb_.EndTable(start_);
3845 auto o = flatbuffers::Offset<InstanceNormalizationDescriptor>(end);
3851 flatbuffers::FlatBufferBuilder &_fbb,
3861 return builder_.
Finish();
3864 struct LogSoftmaxLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3866 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3870 const armnnSerializer::LayerBase *
base()
const {
3871 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3874 return GetPointer<const armnnSerializer::LogSoftmaxDescriptor *>(
VT_DESCRIPTOR);
3876 bool Verify(flatbuffers::Verifier &verifier)
const {
3877 return VerifyTableStart(verifier) &&
3878 VerifyOffset(verifier,
VT_BASE) &&
3879 verifier.VerifyTable(base()) &&
3881 verifier.VerifyTable(descriptor()) &&
3882 verifier.EndTable();
3888 flatbuffers::FlatBufferBuilder &
fbb_;
3890 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3893 void add_descriptor(flatbuffers::Offset<armnnSerializer::LogSoftmaxDescriptor> descriptor) {
3898 start_ = fbb_.StartTable();
3901 flatbuffers::Offset<LogSoftmaxLayer>
Finish() {
3902 const auto end = fbb_.EndTable(start_);
3903 auto o = flatbuffers::Offset<LogSoftmaxLayer>(end);
3909 flatbuffers::FlatBufferBuilder &_fbb,
3910 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3911 flatbuffers::Offset<armnnSerializer::LogSoftmaxDescriptor> descriptor = 0) {
3915 return builder_.
Finish();
3920 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3925 return GetField<float>(
VT_BETA, 1.0f);
3928 return GetField<int32_t>(
VT_AXIS, -1);
3930 bool Verify(flatbuffers::Verifier &verifier)
const {
3931 return VerifyTableStart(verifier) &&
3932 VerifyField<float>(verifier,
VT_BETA) &&
3933 VerifyField<int32_t>(verifier,
VT_AXIS) &&
3934 verifier.EndTable();
3940 flatbuffers::FlatBufferBuilder &
fbb_;
3950 start_ = fbb_.StartTable();
3953 flatbuffers::Offset<LogSoftmaxDescriptor>
Finish() {
3954 const auto end = fbb_.EndTable(start_);
3955 auto o = flatbuffers::Offset<LogSoftmaxDescriptor>(end);
3961 flatbuffers::FlatBufferBuilder &_fbb,
3963 int32_t axis = -1) {
3967 return builder_.
Finish();
3970 struct L2NormalizationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3972 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3976 const armnnSerializer::LayerBase *
base()
const {
3977 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3979 const armnnSerializer::L2NormalizationDescriptor *
descriptor()
const {
3980 return GetPointer<const armnnSerializer::L2NormalizationDescriptor *>(
VT_DESCRIPTOR);
3982 bool Verify(flatbuffers::Verifier &verifier)
const {
3983 return VerifyTableStart(verifier) &&
3984 VerifyOffset(verifier,
VT_BASE) &&
3985 verifier.VerifyTable(base()) &&
3987 verifier.VerifyTable(descriptor()) &&
3988 verifier.EndTable();
3994 flatbuffers::FlatBufferBuilder &
fbb_;
3996 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3999 void add_descriptor(flatbuffers::Offset<armnnSerializer::L2NormalizationDescriptor> descriptor) {
4004 start_ = fbb_.StartTable();
4007 flatbuffers::Offset<L2NormalizationLayer>
Finish() {
4008 const auto end = fbb_.EndTable(start_);
4009 auto o = flatbuffers::Offset<L2NormalizationLayer>(end);
4015 flatbuffers::FlatBufferBuilder &_fbb,
4016 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4017 flatbuffers::Offset<armnnSerializer::L2NormalizationDescriptor> descriptor = 0) {
4021 return builder_.
Finish();
4024 struct L2NormalizationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4026 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4034 return GetField<float>(
VT_EPS, 1e-12f);
4036 bool Verify(flatbuffers::Verifier &verifier)
const {
4037 return VerifyTableStart(verifier) &&
4039 VerifyField<float>(verifier,
VT_EPS) &&
4040 verifier.EndTable();
4045 typedef L2NormalizationDescriptor
Table;
4046 flatbuffers::FlatBufferBuilder &
fbb_;
4056 start_ = fbb_.StartTable();
4059 flatbuffers::Offset<L2NormalizationDescriptor>
Finish() {
4060 const auto end = fbb_.EndTable(start_);
4061 auto o = flatbuffers::Offset<L2NormalizationDescriptor>(end);
4067 flatbuffers::FlatBufferBuilder &_fbb,
4069 float eps = 1e-12f) {
4073 return builder_.
Finish();
4076 struct LogicalBinaryDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4078 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4084 bool Verify(flatbuffers::Verifier &verifier)
const {
4085 return VerifyTableStart(verifier) &&
4086 VerifyField<int8_t>(verifier, VT_OPERATION) &&
4087 verifier.EndTable();
4093 flatbuffers::FlatBufferBuilder &
fbb_;
4096 fbb_.AddElement<int8_t>(LogicalBinaryDescriptor::VT_OPERATION,
static_cast<int8_t
>(operation), 0);
4100 start_ = fbb_.StartTable();
4103 flatbuffers::Offset<LogicalBinaryDescriptor>
Finish() {
4104 const auto end = fbb_.EndTable(start_);
4105 auto o = flatbuffers::Offset<LogicalBinaryDescriptor>(end);
4111 flatbuffers::FlatBufferBuilder &_fbb,
4115 return builder_.
Finish();
4118 struct LogicalBinaryLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4120 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4124 const armnnSerializer::LayerBase *
base()
const {
4125 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4127 const armnnSerializer::LogicalBinaryDescriptor *
descriptor()
const {
4128 return GetPointer<const armnnSerializer::LogicalBinaryDescriptor *>(
VT_DESCRIPTOR);
4130 bool Verify(flatbuffers::Verifier &verifier)
const {
4131 return VerifyTableStart(verifier) &&
4132 VerifyOffset(verifier,
VT_BASE) &&
4133 verifier.VerifyTable(base()) &&
4135 verifier.VerifyTable(descriptor()) &&
4136 verifier.EndTable();
4142 flatbuffers::FlatBufferBuilder &
fbb_;
4144 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4147 void add_descriptor(flatbuffers::Offset<armnnSerializer::LogicalBinaryDescriptor> descriptor) {
4152 start_ = fbb_.StartTable();
4155 flatbuffers::Offset<LogicalBinaryLayer>
Finish() {
4156 const auto end = fbb_.EndTable(start_);
4157 auto o = flatbuffers::Offset<LogicalBinaryLayer>(end);
4163 flatbuffers::FlatBufferBuilder &_fbb,
4164 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4165 flatbuffers::Offset<armnnSerializer::LogicalBinaryDescriptor> descriptor = 0) {
4169 return builder_.
Finish();
4172 struct MinimumLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4174 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4177 const armnnSerializer::LayerBase *
base()
const {
4178 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4180 bool Verify(flatbuffers::Verifier &verifier)
const {
4181 return VerifyTableStart(verifier) &&
4182 VerifyOffset(verifier,
VT_BASE) &&
4183 verifier.VerifyTable(base()) &&
4184 verifier.EndTable();
4190 flatbuffers::FlatBufferBuilder &
fbb_;
4192 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4197 start_ = fbb_.StartTable();
4201 const auto end = fbb_.EndTable(start_);
4202 auto o = flatbuffers::Offset<MinimumLayer>(end);
4208 flatbuffers::FlatBufferBuilder &_fbb,
4209 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4212 return builder_.
Finish();
4215 struct MaximumLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4217 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4220 const armnnSerializer::LayerBase *
base()
const {
4221 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4223 bool Verify(flatbuffers::Verifier &verifier)
const {
4224 return VerifyTableStart(verifier) &&
4225 VerifyOffset(verifier,
VT_BASE) &&
4226 verifier.VerifyTable(base()) &&
4227 verifier.EndTable();
4233 flatbuffers::FlatBufferBuilder &
fbb_;
4235 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4240 start_ = fbb_.StartTable();
4244 const auto end = fbb_.EndTable(start_);
4245 auto o = flatbuffers::Offset<MaximumLayer>(end);
4251 flatbuffers::FlatBufferBuilder &_fbb,
4252 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4255 return builder_.
Finish();
4258 struct MultiplicationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4260 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4263 const armnnSerializer::LayerBase *
base()
const {
4264 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4266 bool Verify(flatbuffers::Verifier &verifier)
const {
4267 return VerifyTableStart(verifier) &&
4268 VerifyOffset(verifier,
VT_BASE) &&
4269 verifier.VerifyTable(base()) &&
4270 verifier.EndTable();
4276 flatbuffers::FlatBufferBuilder &
fbb_;
4278 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4283 start_ = fbb_.StartTable();
4286 flatbuffers::Offset<MultiplicationLayer>
Finish() {
4287 const auto end = fbb_.EndTable(start_);
4288 auto o = flatbuffers::Offset<MultiplicationLayer>(end);
4294 flatbuffers::FlatBufferBuilder &_fbb,
4295 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4298 return builder_.
Finish();
4301 struct Pooling2dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4303 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4307 const armnnSerializer::LayerBase *
base()
const {
4308 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4311 return GetPointer<const armnnSerializer::Pooling2dDescriptor *>(
VT_DESCRIPTOR);
4313 bool Verify(flatbuffers::Verifier &verifier)
const {
4314 return VerifyTableStart(verifier) &&
4315 VerifyOffset(verifier,
VT_BASE) &&
4316 verifier.VerifyTable(base()) &&
4318 verifier.VerifyTable(descriptor()) &&
4319 verifier.EndTable();
4325 flatbuffers::FlatBufferBuilder &
fbb_;
4327 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4330 void add_descriptor(flatbuffers::Offset<armnnSerializer::Pooling2dDescriptor> descriptor) {
4335 start_ = fbb_.StartTable();
4338 flatbuffers::Offset<Pooling2dLayer>
Finish() {
4339 const auto end = fbb_.EndTable(start_);
4340 auto o = flatbuffers::Offset<Pooling2dLayer>(end);
4346 flatbuffers::FlatBufferBuilder &_fbb,
4347 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4348 flatbuffers::Offset<armnnSerializer::Pooling2dDescriptor> descriptor = 0) {
4352 return builder_.
Finish();
4355 struct Pooling2dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4357 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4381 return GetField<uint32_t>(
VT_PADTOP, 0);
4407 bool Verify(flatbuffers::Verifier &verifier)
const {
4408 return VerifyTableStart(verifier) &&
4410 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
4412 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
4416 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
4417 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
4421 verifier.EndTable();
4427 flatbuffers::FlatBufferBuilder &
fbb_;
4467 start_ = fbb_.StartTable();
4470 flatbuffers::Offset<Pooling2dDescriptor>
Finish() {
4471 const auto end = fbb_.EndTable(start_);
4472 auto o = flatbuffers::Offset<Pooling2dDescriptor>(end);
4478 flatbuffers::FlatBufferBuilder &_fbb,
4480 uint32_t padLeft = 0,
4481 uint32_t padRight = 0,
4482 uint32_t padTop = 0,
4483 uint32_t padBottom = 0,
4484 uint32_t poolWidth = 0,
4485 uint32_t poolHeight = 0,
4486 uint32_t strideX = 0,
4487 uint32_t strideY = 0,
4504 return builder_.
Finish();
4507 struct QuantizeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4509 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4512 const armnnSerializer::LayerBase *
base()
const {
4513 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4515 bool Verify(flatbuffers::Verifier &verifier)
const {
4516 return VerifyTableStart(verifier) &&
4517 VerifyOffset(verifier,
VT_BASE) &&
4518 verifier.VerifyTable(base()) &&
4519 verifier.EndTable();
4525 flatbuffers::FlatBufferBuilder &
fbb_;
4527 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4532 start_ = fbb_.StartTable();
4535 flatbuffers::Offset<QuantizeLayer>
Finish() {
4536 const auto end = fbb_.EndTable(start_);
4537 auto o = flatbuffers::Offset<QuantizeLayer>(end);
4543 flatbuffers::FlatBufferBuilder &_fbb,
4544 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4547 return builder_.
Finish();
4550 struct SoftmaxLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4552 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4556 const armnnSerializer::LayerBase *
base()
const {
4557 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4560 return GetPointer<const armnnSerializer::SoftmaxDescriptor *>(
VT_DESCRIPTOR);
4562 bool Verify(flatbuffers::Verifier &verifier)
const {
4563 return VerifyTableStart(verifier) &&
4564 VerifyOffset(verifier,
VT_BASE) &&
4565 verifier.VerifyTable(base()) &&
4567 verifier.VerifyTable(descriptor()) &&
4568 verifier.EndTable();
4574 flatbuffers::FlatBufferBuilder &
fbb_;
4576 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4579 void add_descriptor(flatbuffers::Offset<armnnSerializer::SoftmaxDescriptor> descriptor) {
4584 start_ = fbb_.StartTable();
4588 const auto end = fbb_.EndTable(start_);
4589 auto o = flatbuffers::Offset<SoftmaxLayer>(end);
4595 flatbuffers::FlatBufferBuilder &_fbb,
4596 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4597 flatbuffers::Offset<armnnSerializer::SoftmaxDescriptor> descriptor = 0) {
4601 return builder_.
Finish();
4604 struct SoftmaxDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4606 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4610 return GetField<float>(
VT_BETA, 0.0f);
4612 bool Verify(flatbuffers::Verifier &verifier)
const {
4613 return VerifyTableStart(verifier) &&
4614 VerifyField<float>(verifier,
VT_BETA) &&
4615 verifier.EndTable();
4621 flatbuffers::FlatBufferBuilder &
fbb_;
4628 start_ = fbb_.StartTable();
4631 flatbuffers::Offset<SoftmaxDescriptor>
Finish() {
4632 const auto end = fbb_.EndTable(start_);
4633 auto o = flatbuffers::Offset<SoftmaxDescriptor>(end);
4639 flatbuffers::FlatBufferBuilder &_fbb,
4640 float beta = 0.0f) {
4643 return builder_.
Finish();
4646 struct DepthwiseConvolution2dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4648 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4654 const armnnSerializer::LayerBase *
base()
const {
4655 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4657 const armnnSerializer::DepthwiseConvolution2dDescriptor *
descriptor()
const {
4658 return GetPointer<const armnnSerializer::DepthwiseConvolution2dDescriptor *>(
VT_DESCRIPTOR);
4660 const armnnSerializer::ConstTensor *
weights()
const {
4661 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_WEIGHTS);
4663 const armnnSerializer::ConstTensor *
biases()
const {
4664 return GetPointer<const armnnSerializer::ConstTensor *>(VT_BIASES);
4666 bool Verify(flatbuffers::Verifier &verifier)
const {
4667 return VerifyTableStart(verifier) &&
4668 VerifyOffset(verifier,
VT_BASE) &&
4669 verifier.VerifyTable(base()) &&
4671 verifier.VerifyTable(descriptor()) &&
4673 verifier.VerifyTable(weights()) &&
4674 VerifyOffset(verifier, VT_BIASES) &&
4675 verifier.VerifyTable(biases()) &&
4676 verifier.EndTable();
4681 typedef DepthwiseConvolution2dLayer
Table;
4682 flatbuffers::FlatBufferBuilder &
fbb_;
4684 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4687 void add_descriptor(flatbuffers::Offset<armnnSerializer::DepthwiseConvolution2dDescriptor> descriptor) {
4690 void add_weights(flatbuffers::Offset<armnnSerializer::ConstTensor> weights) {
4693 void add_biases(flatbuffers::Offset<armnnSerializer::ConstTensor> biases) {
4694 fbb_.AddOffset(DepthwiseConvolution2dLayer::VT_BIASES, biases);
4698 start_ = fbb_.StartTable();
4701 flatbuffers::Offset<DepthwiseConvolution2dLayer>
Finish() {
4702 const auto end = fbb_.EndTable(start_);
4703 auto o = flatbuffers::Offset<DepthwiseConvolution2dLayer>(end);
4709 flatbuffers::FlatBufferBuilder &_fbb,
4710 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4711 flatbuffers::Offset<armnnSerializer::DepthwiseConvolution2dDescriptor> descriptor = 0,
4712 flatbuffers::Offset<armnnSerializer::ConstTensor> weights = 0,
4713 flatbuffers::Offset<armnnSerializer::ConstTensor> biases = 0) {
4719 return builder_.
Finish();
4722 struct DepthwiseConvolution2dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4724 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4743 return GetField<uint32_t>(
VT_PADTOP, 0);
4766 bool Verify(flatbuffers::Verifier &verifier)
const {
4767 return VerifyTableStart(verifier) &&
4768 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
4770 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
4772 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
4773 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
4778 verifier.EndTable();
4783 typedef DepthwiseConvolution2dDescriptor
Table;
4784 flatbuffers::FlatBufferBuilder &
fbb_;
4818 start_ = fbb_.StartTable();
4821 flatbuffers::Offset<DepthwiseConvolution2dDescriptor>
Finish() {
4822 const auto end = fbb_.EndTable(start_);
4823 auto o = flatbuffers::Offset<DepthwiseConvolution2dDescriptor>(end);
4829 flatbuffers::FlatBufferBuilder &_fbb,
4830 uint32_t padLeft = 0,
4831 uint32_t padRight = 0,
4832 uint32_t padTop = 0,
4833 uint32_t padBottom = 0,
4834 uint32_t strideX = 0,
4835 uint32_t strideY = 0,
4836 uint32_t dilationX = 1,
4837 uint32_t dilationY = 1,
4838 bool biasEnabled =
false,
4851 return builder_.
Finish();
4854 struct OutputLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4856 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4859 const armnnSerializer::BindableLayerBase *
base()
const {
4860 return GetPointer<const armnnSerializer::BindableLayerBase *>(
VT_BASE);
4862 bool Verify(flatbuffers::Verifier &verifier)
const {
4863 return VerifyTableStart(verifier) &&
4864 VerifyOffset(verifier,
VT_BASE) &&
4865 verifier.VerifyTable(base()) &&
4866 verifier.EndTable();
4872 flatbuffers::FlatBufferBuilder &
fbb_;
4874 void add_base(flatbuffers::Offset<armnnSerializer::BindableLayerBase> base) {
4879 start_ = fbb_.StartTable();
4883 const auto end = fbb_.EndTable(start_);
4884 auto o = flatbuffers::Offset<OutputLayer>(end);
4890 flatbuffers::FlatBufferBuilder &_fbb,
4891 flatbuffers::Offset<armnnSerializer::BindableLayerBase> base = 0) {
4894 return builder_.
Finish();
4897 struct ReshapeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4899 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4903 const armnnSerializer::LayerBase *
base()
const {
4904 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4907 return GetPointer<const armnnSerializer::ReshapeDescriptor *>(
VT_DESCRIPTOR);
4909 bool Verify(flatbuffers::Verifier &verifier)
const {
4910 return VerifyTableStart(verifier) &&
4911 VerifyOffset(verifier,
VT_BASE) &&
4912 verifier.VerifyTable(base()) &&
4914 verifier.VerifyTable(descriptor()) &&
4915 verifier.EndTable();
4921 flatbuffers::FlatBufferBuilder &
fbb_;
4923 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4926 void add_descriptor(flatbuffers::Offset<armnnSerializer::ReshapeDescriptor> descriptor) {
4931 start_ = fbb_.StartTable();
4935 const auto end = fbb_.EndTable(start_);
4936 auto o = flatbuffers::Offset<ReshapeLayer>(end);
4942 flatbuffers::FlatBufferBuilder &_fbb,
4943 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4944 flatbuffers::Offset<armnnSerializer::ReshapeDescriptor> descriptor = 0) {
4948 return builder_.
Finish();
4951 struct ReshapeDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4953 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4957 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_TARGETSHAPE);
4959 bool Verify(flatbuffers::Verifier &verifier)
const {
4960 return VerifyTableStart(verifier) &&
4961 VerifyOffset(verifier, VT_TARGETSHAPE) &&
4962 verifier.VerifyVector(targetShape()) &&
4963 verifier.EndTable();
4969 flatbuffers::FlatBufferBuilder &
fbb_;
4972 fbb_.AddOffset(ReshapeDescriptor::VT_TARGETSHAPE, targetShape);
4976 start_ = fbb_.StartTable();
4979 flatbuffers::Offset<ReshapeDescriptor>
Finish() {
4980 const auto end = fbb_.EndTable(start_);
4981 auto o = flatbuffers::Offset<ReshapeDescriptor>(end);
4987 flatbuffers::FlatBufferBuilder &_fbb,
4991 return builder_.
Finish();
4995 flatbuffers::FlatBufferBuilder &_fbb,
4996 const std::vector<uint32_t> *targetShape =
nullptr) {
4997 auto targetShape__ = targetShape ? _fbb.CreateVector<uint32_t>(*targetShape) : 0;
5003 struct PermuteLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5005 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5009 const armnnSerializer::LayerBase *
base()
const {
5010 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5013 return GetPointer<const armnnSerializer::PermuteDescriptor *>(
VT_DESCRIPTOR);
5015 bool Verify(flatbuffers::Verifier &verifier)
const {
5016 return VerifyTableStart(verifier) &&
5017 VerifyOffset(verifier,
VT_BASE) &&
5018 verifier.VerifyTable(base()) &&
5020 verifier.VerifyTable(descriptor()) &&
5021 verifier.EndTable();
5027 flatbuffers::FlatBufferBuilder &
fbb_;
5029 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5032 void add_descriptor(flatbuffers::Offset<armnnSerializer::PermuteDescriptor> descriptor) {
5037 start_ = fbb_.StartTable();
5041 const auto end = fbb_.EndTable(start_);
5042 auto o = flatbuffers::Offset<PermuteLayer>(end);
5048 flatbuffers::FlatBufferBuilder &_fbb,
5049 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5050 flatbuffers::Offset<armnnSerializer::PermuteDescriptor> descriptor = 0) {
5054 return builder_.
Finish();
5057 struct PermuteDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5059 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5063 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DIMMAPPINGS);
5065 bool Verify(flatbuffers::Verifier &verifier)
const {
5066 return VerifyTableStart(verifier) &&
5067 VerifyOffset(verifier, VT_DIMMAPPINGS) &&
5068 verifier.VerifyVector(dimMappings()) &&
5069 verifier.EndTable();
5075 flatbuffers::FlatBufferBuilder &
fbb_;
5078 fbb_.AddOffset(PermuteDescriptor::VT_DIMMAPPINGS, dimMappings);
5082 start_ = fbb_.StartTable();
5085 flatbuffers::Offset<PermuteDescriptor>
Finish() {
5086 const auto end = fbb_.EndTable(start_);
5087 auto o = flatbuffers::Offset<PermuteDescriptor>(end);
5093 flatbuffers::FlatBufferBuilder &_fbb,
5097 return builder_.
Finish();
5101 flatbuffers::FlatBufferBuilder &_fbb,
5102 const std::vector<uint32_t> *dimMappings =
nullptr) {
5103 auto dimMappings__ = dimMappings ? _fbb.CreateVector<uint32_t>(*dimMappings) : 0;
5109 struct SpaceToBatchNdLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5111 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5115 const armnnSerializer::LayerBase *
base()
const {
5116 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5118 const armnnSerializer::SpaceToBatchNdDescriptor *
descriptor()
const {
5119 return GetPointer<const armnnSerializer::SpaceToBatchNdDescriptor *>(
VT_DESCRIPTOR);
5121 bool Verify(flatbuffers::Verifier &verifier)
const {
5122 return VerifyTableStart(verifier) &&
5123 VerifyOffset(verifier,
VT_BASE) &&
5124 verifier.VerifyTable(base()) &&
5126 verifier.VerifyTable(descriptor()) &&
5127 verifier.EndTable();
5133 flatbuffers::FlatBufferBuilder &
fbb_;
5135 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5138 void add_descriptor(flatbuffers::Offset<armnnSerializer::SpaceToBatchNdDescriptor> descriptor) {
5143 start_ = fbb_.StartTable();
5146 flatbuffers::Offset<SpaceToBatchNdLayer>
Finish() {
5147 const auto end = fbb_.EndTable(start_);
5148 auto o = flatbuffers::Offset<SpaceToBatchNdLayer>(end);
5154 flatbuffers::FlatBufferBuilder &_fbb,
5155 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5156 flatbuffers::Offset<armnnSerializer::SpaceToBatchNdDescriptor> descriptor = 0) {
5160 return builder_.
Finish();
5163 struct SpaceToBatchNdDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5165 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5171 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_BLOCKSHAPE);
5173 const flatbuffers::Vector<uint32_t> *
padList()
const {
5174 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_PADLIST);
5179 bool Verify(flatbuffers::Verifier &verifier)
const {
5180 return VerifyTableStart(verifier) &&
5182 verifier.VerifyVector(blockShape()) &&
5184 verifier.VerifyVector(padList()) &&
5186 verifier.EndTable();
5192 flatbuffers::FlatBufferBuilder &
fbb_;
5205 start_ = fbb_.StartTable();
5208 flatbuffers::Offset<SpaceToBatchNdDescriptor>
Finish() {
5209 const auto end = fbb_.EndTable(start_);
5210 auto o = flatbuffers::Offset<SpaceToBatchNdDescriptor>(end);
5216 flatbuffers::FlatBufferBuilder &_fbb,
5224 return builder_.
Finish();
5228 flatbuffers::FlatBufferBuilder &_fbb,
5229 const std::vector<uint32_t> *blockShape =
nullptr,
5230 const std::vector<uint32_t> *padList =
nullptr,
5232 auto blockShape__ = blockShape ? _fbb.CreateVector<uint32_t>(*blockShape) : 0;
5233 auto padList__ = padList ? _fbb.CreateVector<uint32_t>(*padList) : 0;
5241 struct SpaceToDepthLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5243 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5247 const armnnSerializer::LayerBase *
base()
const {
5248 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5250 const armnnSerializer::SpaceToDepthDescriptor *
descriptor()
const {
5251 return GetPointer<const armnnSerializer::SpaceToDepthDescriptor *>(
VT_DESCRIPTOR);
5253 bool Verify(flatbuffers::Verifier &verifier)
const {
5254 return VerifyTableStart(verifier) &&
5255 VerifyOffset(verifier,
VT_BASE) &&
5256 verifier.VerifyTable(base()) &&
5258 verifier.VerifyTable(descriptor()) &&
5259 verifier.EndTable();
5265 flatbuffers::FlatBufferBuilder &
fbb_;
5267 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5270 void add_descriptor(flatbuffers::Offset<armnnSerializer::SpaceToDepthDescriptor> descriptor) {
5275 start_ = fbb_.StartTable();
5278 flatbuffers::Offset<SpaceToDepthLayer>
Finish() {
5279 const auto end = fbb_.EndTable(start_);
5280 auto o = flatbuffers::Offset<SpaceToDepthLayer>(end);
5286 flatbuffers::FlatBufferBuilder &_fbb,
5287 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5288 flatbuffers::Offset<armnnSerializer::SpaceToDepthDescriptor> descriptor = 0) {
5292 return builder_.
Finish();
5295 struct SpaceToDepthDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5297 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5307 bool Verify(flatbuffers::Verifier &verifier)
const {
5308 return VerifyTableStart(verifier) &&
5311 verifier.EndTable();
5317 flatbuffers::FlatBufferBuilder &
fbb_;
5327 start_ = fbb_.StartTable();
5330 flatbuffers::Offset<SpaceToDepthDescriptor>
Finish() {
5331 const auto end = fbb_.EndTable(start_);
5332 auto o = flatbuffers::Offset<SpaceToDepthDescriptor>(end);
5338 flatbuffers::FlatBufferBuilder &_fbb,
5339 uint32_t blockSize = 0,
5344 return builder_.
Finish();
5347 struct SubtractionLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5349 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5352 const armnnSerializer::LayerBase *
base()
const {
5353 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5355 bool Verify(flatbuffers::Verifier &verifier)
const {
5356 return VerifyTableStart(verifier) &&
5357 VerifyOffset(verifier,
VT_BASE) &&
5358 verifier.VerifyTable(base()) &&
5359 verifier.EndTable();
5365 flatbuffers::FlatBufferBuilder &
fbb_;
5367 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5372 start_ = fbb_.StartTable();
5375 flatbuffers::Offset<SubtractionLayer>
Finish() {
5376 const auto end = fbb_.EndTable(start_);
5377 auto o = flatbuffers::Offset<SubtractionLayer>(end);
5383 flatbuffers::FlatBufferBuilder &_fbb,
5384 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
5387 return builder_.
Finish();
5390 struct BatchToSpaceNdLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5392 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5396 const armnnSerializer::LayerBase *
base()
const {
5397 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5399 const armnnSerializer::BatchToSpaceNdDescriptor *
descriptor()
const {
5400 return GetPointer<const armnnSerializer::BatchToSpaceNdDescriptor *>(
VT_DESCRIPTOR);
5402 bool Verify(flatbuffers::Verifier &verifier)
const {
5403 return VerifyTableStart(verifier) &&
5404 VerifyOffset(verifier,
VT_BASE) &&
5405 verifier.VerifyTable(base()) &&
5407 verifier.VerifyTable(descriptor()) &&
5408 verifier.EndTable();
5414 flatbuffers::FlatBufferBuilder &
fbb_;
5416 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5419 void add_descriptor(flatbuffers::Offset<armnnSerializer::BatchToSpaceNdDescriptor> descriptor) {
5424 start_ = fbb_.StartTable();
5427 flatbuffers::Offset<BatchToSpaceNdLayer>
Finish() {
5428 const auto end = fbb_.EndTable(start_);
5429 auto o = flatbuffers::Offset<BatchToSpaceNdLayer>(end);
5435 flatbuffers::FlatBufferBuilder &_fbb,
5436 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5437 flatbuffers::Offset<armnnSerializer::BatchToSpaceNdDescriptor> descriptor = 0) {
5441 return builder_.
Finish();
5444 struct BatchToSpaceNdDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5446 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5452 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_BLOCKSHAPE);
5454 const flatbuffers::Vector<uint32_t> *
crops()
const {
5455 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_CROPS);
5460 bool Verify(flatbuffers::Verifier &verifier)
const {
5461 return VerifyTableStart(verifier) &&
5463 verifier.VerifyVector(blockShape()) &&
5464 VerifyOffset(verifier,
VT_CROPS) &&
5465 verifier.VerifyVector(crops()) &&
5467 verifier.EndTable();
5473 flatbuffers::FlatBufferBuilder &
fbb_;
5486 start_ = fbb_.StartTable();
5489 flatbuffers::Offset<BatchToSpaceNdDescriptor>
Finish() {
5490 const auto end = fbb_.EndTable(start_);
5491 auto o = flatbuffers::Offset<BatchToSpaceNdDescriptor>(end);
5497 flatbuffers::FlatBufferBuilder &_fbb,
5505 return builder_.
Finish();
5509 flatbuffers::FlatBufferBuilder &_fbb,
5510 const std::vector<uint32_t> *blockShape =
nullptr,
5511 const std::vector<uint32_t> *crops =
nullptr,
5513 auto blockShape__ = blockShape ? _fbb.CreateVector<uint32_t>(*blockShape) : 0;
5514 auto crops__ = crops ? _fbb.CreateVector<uint32_t>(*crops) : 0;
5522 struct NormalizationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5524 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5528 const armnnSerializer::LayerBase *
base()
const {
5529 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5531 const armnnSerializer::NormalizationDescriptor *
descriptor()
const {
5532 return GetPointer<const armnnSerializer::NormalizationDescriptor *>(
VT_DESCRIPTOR);
5534 bool Verify(flatbuffers::Verifier &verifier)
const {
5535 return VerifyTableStart(verifier) &&
5536 VerifyOffset(verifier,
VT_BASE) &&
5537 verifier.VerifyTable(base()) &&
5539 verifier.VerifyTable(descriptor()) &&
5540 verifier.EndTable();
5546 flatbuffers::FlatBufferBuilder &
fbb_;
5548 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5551 void add_descriptor(flatbuffers::Offset<armnnSerializer::NormalizationDescriptor> descriptor) {
5556 start_ = fbb_.StartTable();
5559 flatbuffers::Offset<NormalizationLayer>
Finish() {
5560 const auto end = fbb_.EndTable(start_);
5561 auto o = flatbuffers::Offset<NormalizationLayer>(end);
5567 flatbuffers::FlatBufferBuilder &_fbb,
5568 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5569 flatbuffers::Offset<armnnSerializer::NormalizationDescriptor> descriptor = 0) {
5573 return builder_.
Finish();
5576 struct NormalizationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5578 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5597 return GetField<float>(
VT_ALPHA, 0.0f);
5600 return GetField<float>(
VT_BETA, 0.0f);
5603 return GetField<float>(
VT_K, 0.0f);
5608 bool Verify(flatbuffers::Verifier &verifier)
const {
5609 return VerifyTableStart(verifier) &&
5613 VerifyField<float>(verifier,
VT_ALPHA) &&
5614 VerifyField<float>(verifier,
VT_BETA) &&
5615 VerifyField<float>(verifier,
VT_K) &&
5617 verifier.EndTable();
5623 flatbuffers::FlatBufferBuilder &
fbb_;
5648 start_ = fbb_.StartTable();
5651 flatbuffers::Offset<NormalizationDescriptor>
Finish() {
5652 const auto end = fbb_.EndTable(start_);
5653 auto o = flatbuffers::Offset<NormalizationDescriptor>(end);
5659 flatbuffers::FlatBufferBuilder &_fbb,
5662 uint32_t normSize = 0,
5675 return builder_.
Finish();
5678 struct MeanLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5680 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5684 const armnnSerializer::LayerBase *
base()
const {
5685 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5688 return GetPointer<const armnnSerializer::MeanDescriptor *>(
VT_DESCRIPTOR);
5690 bool Verify(flatbuffers::Verifier &verifier)
const {
5691 return VerifyTableStart(verifier) &&
5692 VerifyOffset(verifier,
VT_BASE) &&
5693 verifier.VerifyTable(base()) &&
5695 verifier.VerifyTable(descriptor()) &&
5696 verifier.EndTable();
5702 flatbuffers::FlatBufferBuilder &
fbb_;
5704 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5707 void add_descriptor(flatbuffers::Offset<armnnSerializer::MeanDescriptor> descriptor) {
5712 start_ = fbb_.StartTable();
5716 const auto end = fbb_.EndTable(start_);
5717 auto o = flatbuffers::Offset<MeanLayer>(end);
5723 flatbuffers::FlatBufferBuilder &_fbb,
5724 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5725 flatbuffers::Offset<armnnSerializer::MeanDescriptor> descriptor = 0) {
5729 return builder_.
Finish();
5732 struct MeanDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5734 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5738 const flatbuffers::Vector<uint32_t> *
axis()
const {
5739 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_AXIS);
5744 bool Verify(flatbuffers::Verifier &verifier)
const {
5745 return VerifyTableStart(verifier) &&
5746 VerifyOffset(verifier,
VT_AXIS) &&
5747 verifier.VerifyVector(axis()) &&
5749 verifier.EndTable();
5755 flatbuffers::FlatBufferBuilder &
fbb_;
5765 start_ = fbb_.StartTable();
5768 flatbuffers::Offset<MeanDescriptor>
Finish() {
5769 const auto end = fbb_.EndTable(start_);
5770 auto o = flatbuffers::Offset<MeanDescriptor>(end);
5776 flatbuffers::FlatBufferBuilder &_fbb,
5778 bool keepDims =
false) {
5782 return builder_.
Finish();
5786 flatbuffers::FlatBufferBuilder &_fbb,
5787 const std::vector<uint32_t> *axis =
nullptr,
5788 bool keepDims =
false) {
5789 auto axis__ = axis ? _fbb.CreateVector<uint32_t>(*axis) : 0;
5796 struct PadLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5798 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5802 const armnnSerializer::LayerBase *
base()
const {
5803 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5806 return GetPointer<const armnnSerializer::PadDescriptor *>(
VT_DESCRIPTOR);
5808 bool Verify(flatbuffers::Verifier &verifier)
const {
5809 return VerifyTableStart(verifier) &&
5810 VerifyOffset(verifier,
VT_BASE) &&
5811 verifier.VerifyTable(base()) &&
5813 verifier.VerifyTable(descriptor()) &&
5814 verifier.EndTable();
5820 flatbuffers::FlatBufferBuilder &
fbb_;
5822 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5825 void add_descriptor(flatbuffers::Offset<armnnSerializer::PadDescriptor> descriptor) {
5830 start_ = fbb_.StartTable();
5834 const auto end = fbb_.EndTable(start_);
5835 auto o = flatbuffers::Offset<PadLayer>(end);
5841 flatbuffers::FlatBufferBuilder &_fbb,
5842 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5843 flatbuffers::Offset<armnnSerializer::PadDescriptor> descriptor = 0) {
5847 return builder_.
Finish();
5850 struct PadDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5852 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5856 const flatbuffers::Vector<uint32_t> *
padList()
const {
5857 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_PADLIST);
5860 return GetField<float>(VT_PADVALUE, 0.0f);
5862 bool Verify(flatbuffers::Verifier &verifier)
const {
5863 return VerifyTableStart(verifier) &&
5865 verifier.VerifyVector(padList()) &&
5866 VerifyField<float>(verifier, VT_PADVALUE) &&
5867 verifier.EndTable();
5873 flatbuffers::FlatBufferBuilder &
fbb_;
5879 fbb_.AddElement<
float>(PadDescriptor::VT_PADVALUE, padValue, 0.0f);
5883 start_ = fbb_.StartTable();
5886 flatbuffers::Offset<PadDescriptor>
Finish() {
5887 const auto end = fbb_.EndTable(start_);
5888 auto o = flatbuffers::Offset<PadDescriptor>(end);
5894 flatbuffers::FlatBufferBuilder &_fbb,
5896 float padValue = 0.0f) {
5900 return builder_.
Finish();
5904 flatbuffers::FlatBufferBuilder &_fbb,
5905 const std::vector<uint32_t> *padList =
nullptr,
5906 float padValue = 0.0f) {
5907 auto padList__ = padList ? _fbb.CreateVector<uint32_t>(*padList) : 0;
5915 struct RsqrtLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5917 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5920 const armnnSerializer::LayerBase *
base()
const {
5921 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5923 bool Verify(flatbuffers::Verifier &verifier)
const {
5924 return VerifyTableStart(verifier) &&
5925 VerifyOffset(verifier,
VT_BASE) &&
5926 verifier.VerifyTable(base()) &&
5927 verifier.EndTable();
5933 flatbuffers::FlatBufferBuilder &
fbb_;
5935 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5940 start_ = fbb_.StartTable();
5944 const auto end = fbb_.EndTable(start_);
5945 auto o = flatbuffers::Offset<RsqrtLayer>(end);
5951 flatbuffers::FlatBufferBuilder &_fbb,
5952 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
5955 return builder_.
Finish();
5958 struct BatchNormalizationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5960 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5968 const armnnSerializer::LayerBase *
base()
const {
5969 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5971 const armnnSerializer::BatchNormalizationDescriptor *
descriptor()
const {
5972 return GetPointer<const armnnSerializer::BatchNormalizationDescriptor *>(
VT_DESCRIPTOR);
5974 const armnnSerializer::ConstTensor *
mean()
const {
5975 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_MEAN);
5978 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_VARIANCE);
5980 const armnnSerializer::ConstTensor *
beta()
const {
5981 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_BETA);
5983 const armnnSerializer::ConstTensor *
gamma()
const {
5984 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_GAMMA);
5986 bool Verify(flatbuffers::Verifier &verifier)
const {
5987 return VerifyTableStart(verifier) &&
5988 VerifyOffset(verifier,
VT_BASE) &&
5989 verifier.VerifyTable(base()) &&
5991 verifier.VerifyTable(descriptor()) &&
5992 VerifyOffset(verifier,
VT_MEAN) &&
5993 verifier.VerifyTable(mean()) &&
5995 verifier.VerifyTable(variance()) &&
5996 VerifyOffset(verifier,
VT_BETA) &&
5997 verifier.VerifyTable(beta()) &&
5998 VerifyOffset(verifier,
VT_GAMMA) &&
5999 verifier.VerifyTable(gamma()) &&
6000 verifier.EndTable();
6006 flatbuffers::FlatBufferBuilder &
fbb_;
6008 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6011 void add_descriptor(flatbuffers::Offset<armnnSerializer::BatchNormalizationDescriptor> descriptor) {
6014 void add_mean(flatbuffers::Offset<armnnSerializer::ConstTensor> mean) {
6017 void add_variance(flatbuffers::Offset<armnnSerializer::ConstTensor> variance) {
6020 void add_beta(flatbuffers::Offset<armnnSerializer::ConstTensor> beta) {
6023 void add_gamma(flatbuffers::Offset<armnnSerializer::ConstTensor> gamma) {
6028 start_ = fbb_.StartTable();
6031 flatbuffers::Offset<BatchNormalizationLayer>
Finish() {
6032 const auto end = fbb_.EndTable(start_);
6033 auto o = flatbuffers::Offset<BatchNormalizationLayer>(end);
6039 flatbuffers::FlatBufferBuilder &_fbb,
6040 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6041 flatbuffers::Offset<armnnSerializer::BatchNormalizationDescriptor> descriptor = 0,
6042 flatbuffers::Offset<armnnSerializer::ConstTensor> mean = 0,
6043 flatbuffers::Offset<armnnSerializer::ConstTensor> variance = 0,
6044 flatbuffers::Offset<armnnSerializer::ConstTensor> beta = 0,
6045 flatbuffers::Offset<armnnSerializer::ConstTensor> gamma = 0) {
6053 return builder_.
Finish();
6056 struct BatchNormalizationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6058 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6063 return GetField<float>(
VT_EPS, 0.0f);
6068 bool Verify(flatbuffers::Verifier &verifier)
const {
6069 return VerifyTableStart(verifier) &&
6070 VerifyField<float>(verifier,
VT_EPS) &&
6072 verifier.EndTable();
6077 typedef BatchNormalizationDescriptor
Table;
6078 flatbuffers::FlatBufferBuilder &
fbb_;
6088 start_ = fbb_.StartTable();
6091 flatbuffers::Offset<BatchNormalizationDescriptor>
Finish() {
6092 const auto end = fbb_.EndTable(start_);
6093 auto o = flatbuffers::Offset<BatchNormalizationDescriptor>(end);
6099 flatbuffers::FlatBufferBuilder &_fbb,
6105 return builder_.
Finish();
6109 struct ResizeBilinearLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6111 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6115 const armnnSerializer::LayerBase *
base()
const {
6116 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6118 const armnnSerializer::ResizeBilinearDescriptor *
descriptor()
const {
6119 return GetPointer<const armnnSerializer::ResizeBilinearDescriptor *>(
VT_DESCRIPTOR);
6121 bool Verify(flatbuffers::Verifier &verifier)
const {
6122 return VerifyTableStart(verifier) &&
6123 VerifyOffset(verifier,
VT_BASE) &&
6124 verifier.VerifyTable(base()) &&
6126 verifier.VerifyTable(descriptor()) &&
6127 verifier.EndTable();
6133 flatbuffers::FlatBufferBuilder &
fbb_;
6135 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6138 void add_descriptor(flatbuffers::Offset<armnnSerializer::ResizeBilinearDescriptor> descriptor) {
6143 start_ = fbb_.StartTable();
6146 flatbuffers::Offset<ResizeBilinearLayer>
Finish() {
6147 const auto end = fbb_.EndTable(start_);
6148 auto o = flatbuffers::Offset<ResizeBilinearLayer>(end);
6154 flatbuffers::FlatBufferBuilder &_fbb,
6155 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6156 flatbuffers::Offset<armnnSerializer::ResizeBilinearDescriptor> descriptor = 0) {
6160 return builder_.
Finish();
6163 struct ResizeBilinearDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6165 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6170 VT_HALFPIXELCENTERS = 12
6185 return GetField<uint8_t>(VT_HALFPIXELCENTERS, 0) != 0;
6187 bool Verify(flatbuffers::Verifier &verifier)
const {
6188 return VerifyTableStart(verifier) &&
6193 VerifyField<uint8_t>(verifier, VT_HALFPIXELCENTERS) &&
6194 verifier.EndTable();
6200 flatbuffers::FlatBufferBuilder &
fbb_;
6215 fbb_.AddElement<uint8_t>(ResizeBilinearDescriptor::VT_HALFPIXELCENTERS,
static_cast<uint8_t
>(halfPixelCenters), 0);
6219 start_ = fbb_.StartTable();
6222 flatbuffers::Offset<ResizeBilinearDescriptor>
Finish() {
6223 const auto end = fbb_.EndTable(start_);
6224 auto o = flatbuffers::Offset<ResizeBilinearDescriptor>(end);
6230 flatbuffers::FlatBufferBuilder &_fbb,
6231 uint32_t targetWidth = 0,
6232 uint32_t targetHeight = 0,
6234 bool alignCorners =
false,
6235 bool halfPixelCenters =
false) {
6242 return builder_.
Finish();
6245 struct SliceLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6247 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6251 const armnnSerializer::LayerBase *
base()
const {
6252 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6255 return GetPointer<const armnnSerializer::SliceDescriptor *>(
VT_DESCRIPTOR);
6257 bool Verify(flatbuffers::Verifier &verifier)
const {
6258 return VerifyTableStart(verifier) &&
6259 VerifyOffset(verifier,
VT_BASE) &&
6260 verifier.VerifyTable(base()) &&
6262 verifier.VerifyTable(descriptor()) &&
6263 verifier.EndTable();
6269 flatbuffers::FlatBufferBuilder &
fbb_;
6271 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6274 void add_descriptor(flatbuffers::Offset<armnnSerializer::SliceDescriptor> descriptor) {
6279 start_ = fbb_.StartTable();
6283 const auto end = fbb_.EndTable(start_);
6284 auto o = flatbuffers::Offset<SliceLayer>(end);
6290 flatbuffers::FlatBufferBuilder &_fbb,
6291 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6292 flatbuffers::Offset<armnnSerializer::SliceDescriptor> descriptor = 0) {
6296 return builder_.
Finish();
6299 struct SliceDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6301 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6305 const flatbuffers::Vector<uint32_t> *
begin()
const {
6306 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_BEGIN);
6308 const flatbuffers::Vector<uint32_t> *
size()
const {
6309 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_SIZE);
6311 bool Verify(flatbuffers::Verifier &verifier)
const {
6312 return VerifyTableStart(verifier) &&
6313 VerifyOffset(verifier,
VT_BEGIN) &&
6314 verifier.VerifyVector(begin()) &&
6315 VerifyOffset(verifier, VT_SIZE) &&
6316 verifier.VerifyVector(size()) &&
6317 verifier.EndTable();
6323 flatbuffers::FlatBufferBuilder &
fbb_;
6329 fbb_.AddOffset(SliceDescriptor::VT_SIZE, size);
6333 start_ = fbb_.StartTable();
6336 flatbuffers::Offset<SliceDescriptor>
Finish() {
6337 const auto end = fbb_.EndTable(start_);
6338 auto o = flatbuffers::Offset<SliceDescriptor>(end);
6344 flatbuffers::FlatBufferBuilder &_fbb,
6350 return builder_.
Finish();
6354 flatbuffers::FlatBufferBuilder &_fbb,
6355 const std::vector<uint32_t> *begin =
nullptr,
6356 const std::vector<uint32_t> *size =
nullptr) {
6357 auto begin__ = begin ? _fbb.CreateVector<uint32_t>(*begin) : 0;
6358 auto size__ = size ? _fbb.CreateVector<uint32_t>(*size) : 0;
6365 struct StridedSliceLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6367 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6371 const armnnSerializer::LayerBase *
base()
const {
6372 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6374 const armnnSerializer::StridedSliceDescriptor *
descriptor()
const {
6375 return GetPointer<const armnnSerializer::StridedSliceDescriptor *>(
VT_DESCRIPTOR);
6377 bool Verify(flatbuffers::Verifier &verifier)
const {
6378 return VerifyTableStart(verifier) &&
6379 VerifyOffset(verifier,
VT_BASE) &&
6380 verifier.VerifyTable(base()) &&
6382 verifier.VerifyTable(descriptor()) &&
6383 verifier.EndTable();
6389 flatbuffers::FlatBufferBuilder &
fbb_;
6391 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6394 void add_descriptor(flatbuffers::Offset<armnnSerializer::StridedSliceDescriptor> descriptor) {
6399 start_ = fbb_.StartTable();
6402 flatbuffers::Offset<StridedSliceLayer>
Finish() {
6403 const auto end = fbb_.EndTable(start_);
6404 auto o = flatbuffers::Offset<StridedSliceLayer>(end);
6410 flatbuffers::FlatBufferBuilder &_fbb,
6411 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6412 flatbuffers::Offset<armnnSerializer::StridedSliceDescriptor> descriptor = 0) {
6416 return builder_.
Finish();
6419 struct StridedSliceDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6421 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6432 const flatbuffers::Vector<int32_t> *
begin()
const {
6433 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_BEGIN);
6435 const flatbuffers::Vector<int32_t> *
end()
const {
6436 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_END);
6438 const flatbuffers::Vector<int32_t> *
stride()
const {
6439 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_STRIDE);
6459 bool Verify(flatbuffers::Verifier &verifier)
const {
6460 return VerifyTableStart(verifier) &&
6461 VerifyOffset(verifier,
VT_BEGIN) &&
6462 verifier.VerifyVector(begin()) &&
6463 VerifyOffset(verifier,
VT_END) &&
6464 verifier.VerifyVector(end()) &&
6466 verifier.VerifyVector(stride()) &&
6468 VerifyField<int32_t>(verifier,
VT_ENDMASK) &&
6473 verifier.EndTable();
6479 flatbuffers::FlatBufferBuilder &
fbb_;
6510 start_ = fbb_.StartTable();
6513 flatbuffers::Offset<StridedSliceDescriptor>
Finish() {
6514 const auto end = fbb_.EndTable(start_);
6515 auto o = flatbuffers::Offset<StridedSliceDescriptor>(end);
6521 flatbuffers::FlatBufferBuilder &_fbb,
6525 int32_t beginMask = 0,
6526 int32_t endMask = 0,
6527 int32_t shrinkAxisMask = 0,
6528 int32_t ellipsisMask = 0,
6529 int32_t newAxisMask = 0,
6541 return builder_.
Finish();
6545 flatbuffers::FlatBufferBuilder &_fbb,
6546 const std::vector<int32_t> *begin =
nullptr,
6547 const std::vector<int32_t> *end =
nullptr,
6548 const std::vector<int32_t> *stride =
nullptr,
6549 int32_t beginMask = 0,
6550 int32_t endMask = 0,
6551 int32_t shrinkAxisMask = 0,
6552 int32_t ellipsisMask = 0,
6553 int32_t newAxisMask = 0,
6555 auto begin__ = begin ? _fbb.CreateVector<int32_t>(*begin) : 0;
6556 auto end__ = end ? _fbb.CreateVector<int32_t>(*end) : 0;
6557 auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0;
6571 struct ConcatLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6573 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6577 const armnnSerializer::LayerBase *
base()
const {
6578 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6581 return GetPointer<const armnnSerializer::OriginsDescriptor *>(
VT_DESCRIPTOR);
6583 bool Verify(flatbuffers::Verifier &verifier)
const {
6584 return VerifyTableStart(verifier) &&
6585 VerifyOffset(verifier,
VT_BASE) &&
6586 verifier.VerifyTable(base()) &&
6588 verifier.VerifyTable(descriptor()) &&
6589 verifier.EndTable();
6595 flatbuffers::FlatBufferBuilder &
fbb_;
6597 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6600 void add_descriptor(flatbuffers::Offset<armnnSerializer::OriginsDescriptor> descriptor) {
6605 start_ = fbb_.StartTable();
6609 const auto end = fbb_.EndTable(start_);
6610 auto o = flatbuffers::Offset<ConcatLayer>(end);
6616 flatbuffers::FlatBufferBuilder &_fbb,
6617 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6618 flatbuffers::Offset<armnnSerializer::OriginsDescriptor> descriptor = 0) {
6622 return builder_.
Finish();
6626 struct MergerLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6628 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6632 const armnnSerializer::LayerBase *
base()
const {
6633 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6636 return GetPointer<const armnnSerializer::OriginsDescriptor *>(
VT_DESCRIPTOR);
6638 bool Verify(flatbuffers::Verifier &verifier)
const {
6639 return VerifyTableStart(verifier) &&
6640 VerifyOffset(verifier,
VT_BASE) &&
6641 verifier.VerifyTable(base()) &&
6643 verifier.VerifyTable(descriptor()) &&
6644 verifier.EndTable();
6650 flatbuffers::FlatBufferBuilder &
fbb_;
6652 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6655 void add_descriptor(flatbuffers::Offset<armnnSerializer::OriginsDescriptor> descriptor) {
6660 start_ = fbb_.StartTable();
6664 const auto end = fbb_.EndTable(start_);
6665 auto o = flatbuffers::Offset<MergerLayer>(end);
6671 flatbuffers::FlatBufferBuilder &_fbb,
6672 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6673 flatbuffers::Offset<armnnSerializer::OriginsDescriptor> descriptor = 0) {
6677 return builder_.
Finish();
6680 struct UintVector FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6682 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6685 const flatbuffers::Vector<uint32_t> *
data()
const {
6686 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DATA);
6688 bool Verify(flatbuffers::Verifier &verifier)
const {
6689 return VerifyTableStart(verifier) &&
6690 VerifyOffset(verifier, VT_DATA) &&
6691 verifier.VerifyVector(data()) &&
6692 verifier.EndTable();
6698 flatbuffers::FlatBufferBuilder &
fbb_;
6701 fbb_.AddOffset(UintVector::VT_DATA, data);
6705 start_ = fbb_.StartTable();
6709 const auto end = fbb_.EndTable(start_);
6710 auto o = flatbuffers::Offset<UintVector>(end);
6716 flatbuffers::FlatBufferBuilder &_fbb,
6720 return builder_.
Finish();
6724 flatbuffers::FlatBufferBuilder &_fbb,
6725 const std::vector<uint32_t> *data =
nullptr) {
6726 auto data__ = data ? _fbb.CreateVector<uint32_t>(*data) : 0;
6732 struct OriginsDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6734 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6749 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>> *
viewOrigins()
const {
6750 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>> *>(VT_VIEWORIGINS);
6752 bool Verify(flatbuffers::Verifier &verifier)
const {
6753 return VerifyTableStart(verifier) &&
6757 VerifyOffset(verifier, VT_VIEWORIGINS) &&
6758 verifier.VerifyVector(viewOrigins()) &&
6759 verifier.VerifyVectorOfTables(viewOrigins()) &&
6760 verifier.EndTable();
6766 flatbuffers::FlatBufferBuilder &
fbb_;
6778 fbb_.AddOffset(OriginsDescriptor::VT_VIEWORIGINS, viewOrigins);
6782 start_ = fbb_.StartTable();
6785 flatbuffers::Offset<OriginsDescriptor>
Finish() {
6786 const auto end = fbb_.EndTable(start_);
6787 auto o = flatbuffers::Offset<OriginsDescriptor>(end);
6793 flatbuffers::FlatBufferBuilder &_fbb,
6794 uint32_t concatAxis = 0,
6795 uint32_t numViews = 0,
6796 uint32_t numDimensions = 0,
6797 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>>> viewOrigins = 0) {
6803 return builder_.
Finish();
6807 flatbuffers::FlatBufferBuilder &_fbb,
6808 uint32_t concatAxis = 0,
6809 uint32_t numViews = 0,
6810 uint32_t numDimensions = 0,
6811 const std::vector<flatbuffers::Offset<armnnSerializer::UintVector>> *viewOrigins =
nullptr) {
6812 auto viewOrigins__ = viewOrigins ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::UintVector>>(*viewOrigins) : 0;
6821 struct ViewsDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6823 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6827 const armnnSerializer::OriginsDescriptor *
origins()
const {
6828 return GetPointer<const armnnSerializer::OriginsDescriptor *>(
VT_ORIGINS);
6830 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>> *
viewSizes()
const {
6831 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>> *>(VT_VIEWSIZES);
6833 bool Verify(flatbuffers::Verifier &verifier)
const {
6834 return VerifyTableStart(verifier) &&
6836 verifier.VerifyTable(origins()) &&
6837 VerifyOffset(verifier, VT_VIEWSIZES) &&
6838 verifier.VerifyVector(viewSizes()) &&
6839 verifier.VerifyVectorOfTables(viewSizes()) &&
6840 verifier.EndTable();
6846 flatbuffers::FlatBufferBuilder &
fbb_;
6848 void add_origins(flatbuffers::Offset<armnnSerializer::OriginsDescriptor> origins) {
6852 fbb_.AddOffset(ViewsDescriptor::VT_VIEWSIZES, viewSizes);
6856 start_ = fbb_.StartTable();
6859 flatbuffers::Offset<ViewsDescriptor>
Finish() {
6860 const auto end = fbb_.EndTable(start_);
6861 auto o = flatbuffers::Offset<ViewsDescriptor>(end);
6867 flatbuffers::FlatBufferBuilder &_fbb,
6868 flatbuffers::Offset<armnnSerializer::OriginsDescriptor> origins = 0,
6869 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>>> viewSizes = 0) {
6873 return builder_.
Finish();
6877 flatbuffers::FlatBufferBuilder &_fbb,
6878 flatbuffers::Offset<armnnSerializer::OriginsDescriptor> origins = 0,
6879 const std::vector<flatbuffers::Offset<armnnSerializer::UintVector>> *viewSizes =
nullptr) {
6880 auto viewSizes__ = viewSizes ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::UintVector>>(*viewSizes) : 0;
6887 struct SplitterLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6889 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6893 const armnnSerializer::LayerBase *
base()
const {
6894 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6897 return GetPointer<const armnnSerializer::ViewsDescriptor *>(
VT_DESCRIPTOR);
6899 bool Verify(flatbuffers::Verifier &verifier)
const {
6900 return VerifyTableStart(verifier) &&
6901 VerifyOffset(verifier,
VT_BASE) &&
6902 verifier.VerifyTable(base()) &&
6904 verifier.VerifyTable(descriptor()) &&
6905 verifier.EndTable();
6911 flatbuffers::FlatBufferBuilder &
fbb_;
6913 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6916 void add_descriptor(flatbuffers::Offset<armnnSerializer::ViewsDescriptor> descriptor) {
6921 start_ = fbb_.StartTable();
6924 flatbuffers::Offset<SplitterLayer>
Finish() {
6925 const auto end = fbb_.EndTable(start_);
6926 auto o = flatbuffers::Offset<SplitterLayer>(end);
6932 flatbuffers::FlatBufferBuilder &_fbb,
6933 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6934 flatbuffers::Offset<armnnSerializer::ViewsDescriptor> descriptor = 0) {
6938 return builder_.
Finish();
6941 struct DetectionPostProcessLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6943 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6948 const armnnSerializer::LayerBase *
base()
const {
6949 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6951 const armnnSerializer::DetectionPostProcessDescriptor *
descriptor()
const {
6952 return GetPointer<const armnnSerializer::DetectionPostProcessDescriptor *>(
VT_DESCRIPTOR);
6954 const armnnSerializer::ConstTensor *
anchors()
const {
6955 return GetPointer<const armnnSerializer::ConstTensor *>(VT_ANCHORS);
6957 bool Verify(flatbuffers::Verifier &verifier)
const {
6958 return VerifyTableStart(verifier) &&
6959 VerifyOffset(verifier,
VT_BASE) &&
6960 verifier.VerifyTable(base()) &&
6962 verifier.VerifyTable(descriptor()) &&
6963 VerifyOffset(verifier, VT_ANCHORS) &&
6964 verifier.VerifyTable(
anchors()) &&
6965 verifier.EndTable();
6970 typedef DetectionPostProcessLayer
Table;
6971 flatbuffers::FlatBufferBuilder &
fbb_;
6973 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6976 void add_descriptor(flatbuffers::Offset<armnnSerializer::DetectionPostProcessDescriptor> descriptor) {
6980 fbb_.AddOffset(DetectionPostProcessLayer::VT_ANCHORS, anchors);
6984 start_ = fbb_.StartTable();
6987 flatbuffers::Offset<DetectionPostProcessLayer>
Finish() {
6988 const auto end = fbb_.EndTable(start_);
6989 auto o = flatbuffers::Offset<DetectionPostProcessLayer>(end);
6995 flatbuffers::FlatBufferBuilder &_fbb,
6996 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6997 flatbuffers::Offset<armnnSerializer::DetectionPostProcessDescriptor> descriptor = 0,
6998 flatbuffers::Offset<armnnSerializer::ConstTensor>
anchors = 0) {
7003 return builder_.
Finish();
7006 struct DetectionPostProcessDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7008 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7043 return GetField<float>(
VT_SCALEX, 0.0f);
7046 return GetField<float>(
VT_SCALEY, 0.0f);
7049 return GetField<float>(
VT_SCALEW, 0.0f);
7052 return GetField<float>(VT_SCALEH, 0.0f);
7054 bool Verify(flatbuffers::Verifier &verifier)
const {
7055 return VerifyTableStart(verifier) &&
7063 VerifyField<float>(verifier,
VT_SCALEX) &&
7064 VerifyField<float>(verifier,
VT_SCALEY) &&
7065 VerifyField<float>(verifier,
VT_SCALEW) &&
7066 VerifyField<float>(verifier, VT_SCALEH) &&
7067 verifier.EndTable();
7072 typedef DetectionPostProcessDescriptor
Table;
7073 flatbuffers::FlatBufferBuilder &
fbb_;
7106 fbb_.AddElement<
float>(DetectionPostProcessDescriptor::VT_SCALEH, scaleH, 0.0f);
7110 start_ = fbb_.StartTable();
7113 flatbuffers::Offset<DetectionPostProcessDescriptor>
Finish() {
7114 const auto end = fbb_.EndTable(start_);
7115 auto o = flatbuffers::Offset<DetectionPostProcessDescriptor>(end);
7121 flatbuffers::FlatBufferBuilder &_fbb,
7122 uint32_t maxDetections = 0,
7123 uint32_t maxClassesPerDetection = 0,
7124 uint32_t detectionsPerClass = 0,
7125 float nmsScoreThreshold = 0.0f,
7126 float nmsIouThreshold = 0.0f,
7127 uint32_t numClasses = 0,
7128 bool useRegularNms =
false,
7129 float scaleX = 0.0f,
7130 float scaleY = 0.0f,
7131 float scaleW = 0.0f,
7132 float scaleH = 0.0f) {
7145 return builder_.
Finish();
7148 struct LstmInputParams FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7150 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7171 VT_OUTPUTLAYERNORMWEIGHTS = 44
7195 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_CELLBIAS);
7234 return GetPointer<const armnnSerializer::ConstTensor *>(VT_OUTPUTLAYERNORMWEIGHTS);
7236 bool Verify(flatbuffers::Verifier &verifier)
const {
7237 return VerifyTableStart(verifier) &&
7239 verifier.VerifyTable(inputToForgetWeights()) &&
7241 verifier.VerifyTable(inputToCellWeights()) &&
7243 verifier.VerifyTable(inputToOutputWeights()) &&
7245 verifier.VerifyTable(recurrentToForgetWeights()) &&
7247 verifier.VerifyTable(recurrentToCellWeights()) &&
7249 verifier.VerifyTable(recurrentToOutputWeights()) &&
7251 verifier.VerifyTable(forgetGateBias()) &&
7253 verifier.VerifyTable(cellBias()) &&
7255 verifier.VerifyTable(outputGateBias()) &&
7257 verifier.VerifyTable(inputToInputWeights()) &&
7259 verifier.VerifyTable(recurrentToInputWeights()) &&
7261 verifier.VerifyTable(cellToInputWeights()) &&
7263 verifier.VerifyTable(inputGateBias()) &&
7265 verifier.VerifyTable(projectionWeights()) &&
7267 verifier.VerifyTable(projectionBias()) &&
7269 verifier.VerifyTable(cellToForgetWeights()) &&
7271 verifier.VerifyTable(cellToOutputWeights()) &&
7273 verifier.VerifyTable(inputLayerNormWeights()) &&
7275 verifier.VerifyTable(forgetLayerNormWeights()) &&
7277 verifier.VerifyTable(cellLayerNormWeights()) &&
7278 VerifyOffset(verifier, VT_OUTPUTLAYERNORMWEIGHTS) &&
7279 verifier.VerifyTable(outputLayerNormWeights()) &&
7280 verifier.EndTable();
7286 flatbuffers::FlatBufferBuilder &
fbb_;
7309 void add_cellBias(flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias) {
7349 fbb_.AddOffset(LstmInputParams::VT_OUTPUTLAYERNORMWEIGHTS, outputLayerNormWeights);
7353 start_ = fbb_.StartTable();
7356 flatbuffers::Offset<LstmInputParams>
Finish() {
7357 const auto end = fbb_.EndTable(start_);
7358 auto o = flatbuffers::Offset<LstmInputParams>(end);
7364 flatbuffers::FlatBufferBuilder &_fbb,
7365 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToForgetWeights = 0,
7366 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToCellWeights = 0,
7367 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToOutputWeights = 0,
7368 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToForgetWeights = 0,
7369 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToCellWeights = 0,
7370 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToOutputWeights = 0,
7371 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetGateBias = 0,
7372 flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias = 0,
7373 flatbuffers::Offset<armnnSerializer::ConstTensor> outputGateBias = 0,
7374 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToInputWeights = 0,
7375 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToInputWeights = 0,
7376 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToInputWeights = 0,
7377 flatbuffers::Offset<armnnSerializer::ConstTensor> inputGateBias = 0,
7378 flatbuffers::Offset<armnnSerializer::ConstTensor> projectionWeights = 0,
7379 flatbuffers::Offset<armnnSerializer::ConstTensor> projectionBias = 0,
7380 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToForgetWeights = 0,
7381 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToOutputWeights = 0,
7382 flatbuffers::Offset<armnnSerializer::ConstTensor> inputLayerNormWeights = 0,
7383 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetLayerNormWeights = 0,
7384 flatbuffers::Offset<armnnSerializer::ConstTensor> cellLayerNormWeights = 0,
7385 flatbuffers::Offset<armnnSerializer::ConstTensor> outputLayerNormWeights = 0) {
7408 return builder_.
Finish();
7411 struct LstmDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7413 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7443 bool Verify(flatbuffers::Verifier &verifier)
const {
7444 return VerifyTableStart(verifier) &&
7452 verifier.EndTable();
7458 flatbuffers::FlatBufferBuilder &
fbb_;
7483 start_ = fbb_.StartTable();
7486 flatbuffers::Offset<LstmDescriptor>
Finish() {
7487 const auto end = fbb_.EndTable(start_);
7488 auto o = flatbuffers::Offset<LstmDescriptor>(end);
7494 flatbuffers::FlatBufferBuilder &_fbb,
7495 uint32_t activationFunc = 0,
7496 float clippingThresCell = 0.0f,
7497 float clippingThresProj = 0.0f,
7498 bool cifgEnabled =
true,
7499 bool peepholeEnabled =
false,
7500 bool projectionEnabled =
false,
7501 bool layerNormEnabled =
false) {
7510 return builder_.
Finish();
7513 struct LstmLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7515 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7520 const armnnSerializer::LayerBase *
base()
const {
7521 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
7524 return GetPointer<const armnnSerializer::LstmDescriptor *>(
VT_DESCRIPTOR);
7527 return GetPointer<const armnnSerializer::LstmInputParams *>(VT_INPUTPARAMS);
7529 bool Verify(flatbuffers::Verifier &verifier)
const {
7530 return VerifyTableStart(verifier) &&
7531 VerifyOffset(verifier,
VT_BASE) &&
7532 verifier.VerifyTable(base()) &&
7534 verifier.VerifyTable(descriptor()) &&
7535 VerifyOffset(verifier, VT_INPUTPARAMS) &&
7536 verifier.VerifyTable(inputParams()) &&
7537 verifier.EndTable();
7543 flatbuffers::FlatBufferBuilder &
fbb_;
7545 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
7548 void add_descriptor(flatbuffers::Offset<armnnSerializer::LstmDescriptor> descriptor) {
7552 fbb_.AddOffset(LstmLayer::VT_INPUTPARAMS, inputParams);
7556 start_ = fbb_.StartTable();
7560 const auto end = fbb_.EndTable(start_);
7561 auto o = flatbuffers::Offset<LstmLayer>(end);
7567 flatbuffers::FlatBufferBuilder &_fbb,
7568 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7569 flatbuffers::Offset<armnnSerializer::LstmDescriptor> descriptor = 0,
7570 flatbuffers::Offset<armnnSerializer::LstmInputParams> inputParams = 0) {
7575 return builder_.
Finish();
7578 struct QLstmInputParams FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7580 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7601 VT_OUTPUTLAYERNORMWEIGHTS = 44
7625 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_CELLBIAS);
7664 return GetPointer<const armnnSerializer::ConstTensor *>(VT_OUTPUTLAYERNORMWEIGHTS);
7666 bool Verify(flatbuffers::Verifier &verifier)
const {
7667 return VerifyTableStart(verifier) &&
7669 verifier.VerifyTable(inputToForgetWeights()) &&
7671 verifier.VerifyTable(inputToCellWeights()) &&
7673 verifier.VerifyTable(inputToOutputWeights()) &&
7675 verifier.VerifyTable(recurrentToForgetWeights()) &&
7677 verifier.VerifyTable(recurrentToCellWeights()) &&
7679 verifier.VerifyTable(recurrentToOutputWeights()) &&
7681 verifier.VerifyTable(forgetGateBias()) &&
7683 verifier.VerifyTable(cellBias()) &&
7685 verifier.VerifyTable(outputGateBias()) &&
7687 verifier.VerifyTable(inputToInputWeights()) &&
7689 verifier.VerifyTable(recurrentToInputWeights()) &&
7691 verifier.VerifyTable(inputGateBias()) &&
7693 verifier.VerifyTable(projectionWeights()) &&
7695 verifier.VerifyTable(projectionBias()) &&
7697 verifier.VerifyTable(cellToInputWeights()) &&
7699 verifier.VerifyTable(cellToForgetWeights()) &&
7701 verifier.VerifyTable(cellToOutputWeights()) &&
7703 verifier.VerifyTable(inputLayerNormWeights()) &&
7705 verifier.VerifyTable(forgetLayerNormWeights()) &&
7707 verifier.VerifyTable(cellLayerNormWeights()) &&
7708 VerifyOffset(verifier, VT_OUTPUTLAYERNORMWEIGHTS) &&
7709 verifier.VerifyTable(outputLayerNormWeights()) &&
7710 verifier.EndTable();
7716 flatbuffers::FlatBufferBuilder &
fbb_;
7739 void add_cellBias(flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias) {
7779 fbb_.AddOffset(QLstmInputParams::VT_OUTPUTLAYERNORMWEIGHTS, outputLayerNormWeights);
7783 start_ = fbb_.StartTable();
7786 flatbuffers::Offset<QLstmInputParams>
Finish() {
7787 const auto end = fbb_.EndTable(start_);
7788 auto o = flatbuffers::Offset<QLstmInputParams>(end);
7794 flatbuffers::FlatBufferBuilder &_fbb,
7795 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToForgetWeights = 0,
7796 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToCellWeights = 0,
7797 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToOutputWeights = 0,
7798 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToForgetWeights = 0,
7799 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToCellWeights = 0,
7800 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToOutputWeights = 0,
7801 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetGateBias = 0,
7802 flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias = 0,
7803 flatbuffers::Offset<armnnSerializer::ConstTensor> outputGateBias = 0,
7804 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToInputWeights = 0,
7805 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToInputWeights = 0,
7806 flatbuffers::Offset<armnnSerializer::ConstTensor> inputGateBias = 0,
7807 flatbuffers::Offset<armnnSerializer::ConstTensor> projectionWeights = 0,
7808 flatbuffers::Offset<armnnSerializer::ConstTensor> projectionBias = 0,
7809 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToInputWeights = 0,
7810 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToForgetWeights = 0,
7811 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToOutputWeights = 0,
7812 flatbuffers::Offset<armnnSerializer::ConstTensor> inputLayerNormWeights = 0,
7813 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetLayerNormWeights = 0,
7814 flatbuffers::Offset<armnnSerializer::ConstTensor> cellLayerNormWeights = 0,
7815 flatbuffers::Offset<armnnSerializer::ConstTensor> outputLayerNormWeights = 0) {
7838 return builder_.
Finish();
7841 struct QLstmDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7843 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7855 VT_HIDDENSTATESCALE = 26
7891 return GetField<float>(VT_HIDDENSTATESCALE, 0.0f);
7893 bool Verify(flatbuffers::Verifier &verifier)
const {
7894 return VerifyTableStart(verifier) &&
7906 VerifyField<float>(verifier, VT_HIDDENSTATESCALE) &&
7907 verifier.EndTable();
7913 flatbuffers::FlatBufferBuilder &
fbb_;
7949 fbb_.AddElement<
float>(QLstmDescriptor::VT_HIDDENSTATESCALE, hiddenStateScale, 0.0f);
7953 start_ = fbb_.StartTable();
7956 flatbuffers::Offset<QLstmDescriptor>
Finish() {
7957 const auto end = fbb_.EndTable(start_);
7958 auto o = flatbuffers::Offset<QLstmDescriptor>(end);
7964 flatbuffers::FlatBufferBuilder &_fbb,
7965 bool cifgEnabled =
true,
7966 bool peepholeEnabled =
false,
7967 bool projectionEnabled =
false,
7968 bool layerNormEnabled =
false,
7969 float cellClip = 0.0f,
7970 float projectionClip = 0.0f,
7971 float inputIntermediateScale = 0.0f,
7972 float forgetIntermediateScale = 0.0f,
7973 float cellIntermediateScale = 0.0f,
7974 float outputIntermediateScale = 0.0f,
7975 int32_t hiddenStateZeroPoint = 0,
7976 float hiddenStateScale = 0.0f) {
7990 return builder_.
Finish();
7993 struct QLstmLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7995 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8000 const armnnSerializer::LayerBase *
base()
const {
8001 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8004 return GetPointer<const armnnSerializer::QLstmDescriptor *>(
VT_DESCRIPTOR);
8007 return GetPointer<const armnnSerializer::QLstmInputParams *>(VT_INPUTPARAMS);
8009 bool Verify(flatbuffers::Verifier &verifier)
const {
8010 return VerifyTableStart(verifier) &&
8011 VerifyOffset(verifier,
VT_BASE) &&
8012 verifier.VerifyTable(base()) &&
8014 verifier.VerifyTable(descriptor()) &&
8015 VerifyOffset(verifier, VT_INPUTPARAMS) &&
8016 verifier.VerifyTable(inputParams()) &&
8017 verifier.EndTable();
8023 flatbuffers::FlatBufferBuilder &
fbb_;
8025 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8028 void add_descriptor(flatbuffers::Offset<armnnSerializer::QLstmDescriptor> descriptor) {
8031 void add_inputParams(flatbuffers::Offset<armnnSerializer::QLstmInputParams> inputParams) {
8032 fbb_.AddOffset(QLstmLayer::VT_INPUTPARAMS, inputParams);
8036 start_ = fbb_.StartTable();
8040 const auto end = fbb_.EndTable(start_);
8041 auto o = flatbuffers::Offset<QLstmLayer>(end);
8047 flatbuffers::FlatBufferBuilder &_fbb,
8048 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
8049 flatbuffers::Offset<armnnSerializer::QLstmDescriptor> descriptor = 0,
8050 flatbuffers::Offset<armnnSerializer::QLstmInputParams> inputParams = 0) {
8055 return builder_.
Finish();
8058 struct QuantizedLstmInputParams FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8060 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8105 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_CELLBIAS);
8110 bool Verify(flatbuffers::Verifier &verifier)
const {
8111 return VerifyTableStart(verifier) &&
8113 verifier.VerifyTable(inputToInputWeights()) &&
8115 verifier.VerifyTable(inputToForgetWeights()) &&
8117 verifier.VerifyTable(inputToCellWeights()) &&
8119 verifier.VerifyTable(inputToOutputWeights()) &&
8121 verifier.VerifyTable(recurrentToInputWeights()) &&
8123 verifier.VerifyTable(recurrentToForgetWeights()) &&
8125 verifier.VerifyTable(recurrentToCellWeights()) &&
8127 verifier.VerifyTable(recurrentToOutputWeights()) &&
8129 verifier.VerifyTable(inputGateBias()) &&
8131 verifier.VerifyTable(forgetGateBias()) &&
8133 verifier.VerifyTable(cellBias()) &&
8135 verifier.VerifyTable(outputGateBias()) &&
8136 verifier.EndTable();
8142 flatbuffers::FlatBufferBuilder &
fbb_;
8174 void add_cellBias(flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias) {
8182 start_ = fbb_.StartTable();
8185 flatbuffers::Offset<QuantizedLstmInputParams>
Finish() {
8186 const auto end = fbb_.EndTable(start_);
8187 auto o = flatbuffers::Offset<QuantizedLstmInputParams>(end);
8193 flatbuffers::FlatBufferBuilder &_fbb,
8194 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToInputWeights = 0,
8195 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToForgetWeights = 0,
8196 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToCellWeights = 0,
8197 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToOutputWeights = 0,
8198 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToInputWeights = 0,
8199 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToForgetWeights = 0,
8200 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToCellWeights = 0,
8201 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToOutputWeights = 0,
8202 flatbuffers::Offset<armnnSerializer::ConstTensor> inputGateBias = 0,
8203 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetGateBias = 0,
8204 flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias = 0,
8205 flatbuffers::Offset<armnnSerializer::ConstTensor> outputGateBias = 0) {
8219 return builder_.
Finish();
8222 struct QuantizedLstmLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8224 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8228 const armnnSerializer::LayerBase *
base()
const {
8229 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8231 const armnnSerializer::QuantizedLstmInputParams *
inputParams()
const {
8232 return GetPointer<const armnnSerializer::QuantizedLstmInputParams *>(VT_INPUTPARAMS);
8234 bool Verify(flatbuffers::Verifier &verifier)
const {
8235 return VerifyTableStart(verifier) &&
8236 VerifyOffset(verifier,
VT_BASE) &&
8237 verifier.VerifyTable(base()) &&
8238 VerifyOffset(verifier, VT_INPUTPARAMS) &&
8239 verifier.VerifyTable(inputParams()) &&
8240 verifier.EndTable();
8246 flatbuffers::FlatBufferBuilder &
fbb_;
8248 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8251 void add_inputParams(flatbuffers::Offset<armnnSerializer::QuantizedLstmInputParams> inputParams) {
8252 fbb_.AddOffset(QuantizedLstmLayer::VT_INPUTPARAMS, inputParams);
8256 start_ = fbb_.StartTable();
8259 flatbuffers::Offset<QuantizedLstmLayer>
Finish() {
8260 const auto end = fbb_.EndTable(start_);
8261 auto o = flatbuffers::Offset<QuantizedLstmLayer>(end);
8267 flatbuffers::FlatBufferBuilder &_fbb,
8268 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
8269 flatbuffers::Offset<armnnSerializer::QuantizedLstmInputParams> inputParams = 0) {
8273 return builder_.
Finish();
8276 struct DequantizeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8278 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8281 const armnnSerializer::LayerBase *
base()
const {
8282 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8284 bool Verify(flatbuffers::Verifier &verifier)
const {
8285 return VerifyTableStart(verifier) &&
8286 VerifyOffset(verifier,
VT_BASE) &&
8287 verifier.VerifyTable(base()) &&
8288 verifier.EndTable();
8294 flatbuffers::FlatBufferBuilder &
fbb_;
8296 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8301 start_ = fbb_.StartTable();
8304 flatbuffers::Offset<DequantizeLayer>
Finish() {
8305 const auto end = fbb_.EndTable(start_);
8306 auto o = flatbuffers::Offset<DequantizeLayer>(end);
8312 flatbuffers::FlatBufferBuilder &_fbb,
8313 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
8316 return builder_.
Finish();
8319 struct MergeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8321 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8324 const armnnSerializer::LayerBase *
base()
const {
8325 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8327 bool Verify(flatbuffers::Verifier &verifier)
const {
8328 return VerifyTableStart(verifier) &&
8329 VerifyOffset(verifier,
VT_BASE) &&
8330 verifier.VerifyTable(base()) &&
8331 verifier.EndTable();
8337 flatbuffers::FlatBufferBuilder &
fbb_;
8339 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8344 start_ = fbb_.StartTable();
8348 const auto end = fbb_.EndTable(start_);
8349 auto o = flatbuffers::Offset<MergeLayer>(end);
8355 flatbuffers::FlatBufferBuilder &_fbb,
8356 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
8359 return builder_.
Finish();
8362 struct SwitchLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8364 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8367 const armnnSerializer::LayerBase *
base()
const {
8368 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8370 bool Verify(flatbuffers::Verifier &verifier)
const {
8371 return VerifyTableStart(verifier) &&
8372 VerifyOffset(verifier,
VT_BASE) &&
8373 verifier.VerifyTable(base()) &&
8374 verifier.EndTable();
8380 flatbuffers::FlatBufferBuilder &
fbb_;
8382 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8387 start_ = fbb_.StartTable();
8391 const auto end = fbb_.EndTable(start_);
8392 auto o = flatbuffers::Offset<SwitchLayer>(end);
8398 flatbuffers::FlatBufferBuilder &_fbb,
8399 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
8402 return builder_.
Finish();
8405 struct PreluLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8407 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8410 const armnnSerializer::LayerBase *
base()
const {
8411 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8413 bool Verify(flatbuffers::Verifier &verifier)
const {
8414 return VerifyTableStart(verifier) &&
8415 VerifyOffset(verifier,
VT_BASE) &&
8416 verifier.VerifyTable(base()) &&
8417 verifier.EndTable();
8423 flatbuffers::FlatBufferBuilder &
fbb_;
8425 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8430 start_ = fbb_.StartTable();
8434 const auto end = fbb_.EndTable(start_);
8435 auto o = flatbuffers::Offset<PreluLayer>(end);
8441 flatbuffers::FlatBufferBuilder &_fbb,
8442 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
8445 return builder_.
Finish();
8448 struct TransposeConvolution2dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8450 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8456 const armnnSerializer::LayerBase *
base()
const {
8457 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8459 const armnnSerializer::TransposeConvolution2dDescriptor *
descriptor()
const {
8460 return GetPointer<const armnnSerializer::TransposeConvolution2dDescriptor *>(
VT_DESCRIPTOR);
8462 const armnnSerializer::ConstTensor *
weights()
const {
8463 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_WEIGHTS);
8465 const armnnSerializer::ConstTensor *
biases()
const {
8466 return GetPointer<const armnnSerializer::ConstTensor *>(VT_BIASES);
8468 bool Verify(flatbuffers::Verifier &verifier)
const {
8469 return VerifyTableStart(verifier) &&
8470 VerifyOffset(verifier,
VT_BASE) &&
8471 verifier.VerifyTable(base()) &&
8473 verifier.VerifyTable(descriptor()) &&
8475 verifier.VerifyTable(weights()) &&
8476 VerifyOffset(verifier, VT_BIASES) &&
8477 verifier.VerifyTable(biases()) &&
8478 verifier.EndTable();
8483 typedef TransposeConvolution2dLayer
Table;
8484 flatbuffers::FlatBufferBuilder &
fbb_;
8486 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8489 void add_descriptor(flatbuffers::Offset<armnnSerializer::TransposeConvolution2dDescriptor> descriptor) {
8492 void add_weights(flatbuffers::Offset<armnnSerializer::ConstTensor> weights) {
8495 void add_biases(flatbuffers::Offset<armnnSerializer::ConstTensor> biases) {
8496 fbb_.AddOffset(TransposeConvolution2dLayer::VT_BIASES, biases);
8500 start_ = fbb_.StartTable();
8503 flatbuffers::Offset<TransposeConvolution2dLayer>
Finish() {
8504 const auto end = fbb_.EndTable(start_);
8505 auto o = flatbuffers::Offset<TransposeConvolution2dLayer>(end);
8511 flatbuffers::FlatBufferBuilder &_fbb,
8512 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
8513 flatbuffers::Offset<armnnSerializer::TransposeConvolution2dDescriptor> descriptor = 0,
8514 flatbuffers::Offset<armnnSerializer::ConstTensor> weights = 0,
8515 flatbuffers::Offset<armnnSerializer::ConstTensor> biases = 0) {
8521 return builder_.
Finish();
8524 struct TransposeConvolution2dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8526 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8543 return GetField<uint32_t>(
VT_PADTOP, 0);
8560 bool Verify(flatbuffers::Verifier &verifier)
const {
8561 return VerifyTableStart(verifier) &&
8562 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
8564 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
8566 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
8567 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
8570 verifier.EndTable();
8575 typedef TransposeConvolution2dDescriptor
Table;
8576 flatbuffers::FlatBufferBuilder &
fbb_;
8604 start_ = fbb_.StartTable();
8607 flatbuffers::Offset<TransposeConvolution2dDescriptor>
Finish() {
8608 const auto end = fbb_.EndTable(start_);
8609 auto o = flatbuffers::Offset<TransposeConvolution2dDescriptor>(end);
8615 flatbuffers::FlatBufferBuilder &_fbb,
8616 uint32_t padLeft = 0,
8617 uint32_t padRight = 0,
8618 uint32_t padTop = 0,
8619 uint32_t padBottom = 0,
8620 uint32_t strideX = 0,
8621 uint32_t strideY = 0,
8622 bool biasEnabled =
false,
8633 return builder_.
Finish();
8636 struct TransposeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8638 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8642 const armnnSerializer::LayerBase *
base()
const {
8643 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8646 return GetPointer<const armnnSerializer::TransposeDescriptor *>(
VT_DESCRIPTOR);
8648 bool Verify(flatbuffers::Verifier &verifier)
const {
8649 return VerifyTableStart(verifier) &&
8650 VerifyOffset(verifier,
VT_BASE) &&
8651 verifier.VerifyTable(base()) &&
8653 verifier.VerifyTable(descriptor()) &&
8654 verifier.EndTable();
8660 flatbuffers::FlatBufferBuilder &
fbb_;
8662 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8665 void add_descriptor(flatbuffers::Offset<armnnSerializer::TransposeDescriptor> descriptor) {
8670 start_ = fbb_.StartTable();
8673 flatbuffers::Offset<TransposeLayer>
Finish() {
8674 const auto end = fbb_.EndTable(start_);
8675 auto o = flatbuffers::Offset<TransposeLayer>(end);
8681 flatbuffers::FlatBufferBuilder &_fbb,
8682 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
8683 flatbuffers::Offset<armnnSerializer::TransposeDescriptor> descriptor = 0) {
8687 return builder_.
Finish();
8690 struct TransposeDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8692 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8696 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DIMMAPPINGS);
8698 bool Verify(flatbuffers::Verifier &verifier)
const {
8699 return VerifyTableStart(verifier) &&
8700 VerifyOffset(verifier, VT_DIMMAPPINGS) &&
8701 verifier.VerifyVector(dimMappings()) &&
8702 verifier.EndTable();
8708 flatbuffers::FlatBufferBuilder &
fbb_;
8711 fbb_.AddOffset(TransposeDescriptor::VT_DIMMAPPINGS, dimMappings);
8715 start_ = fbb_.StartTable();
8718 flatbuffers::Offset<TransposeDescriptor>
Finish() {
8719 const auto end = fbb_.EndTable(start_);
8720 auto o = flatbuffers::Offset<TransposeDescriptor>(end);
8726 flatbuffers::FlatBufferBuilder &_fbb,
8730 return builder_.
Finish();
8734 flatbuffers::FlatBufferBuilder &_fbb,
8735 const std::vector<uint32_t> *dimMappings =
nullptr) {
8736 auto dimMappings__ = dimMappings ? _fbb.CreateVector<uint32_t>(*dimMappings) : 0;
8742 struct ResizeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8744 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8748 const armnnSerializer::LayerBase *
base()
const {
8749 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8752 return GetPointer<const armnnSerializer::ResizeDescriptor *>(
VT_DESCRIPTOR);
8754 bool Verify(flatbuffers::Verifier &verifier)
const {
8755 return VerifyTableStart(verifier) &&
8756 VerifyOffset(verifier,
VT_BASE) &&
8757 verifier.VerifyTable(base()) &&
8759 verifier.VerifyTable(descriptor()) &&
8760 verifier.EndTable();
8766 flatbuffers::FlatBufferBuilder &
fbb_;
8768 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8771 void add_descriptor(flatbuffers::Offset<armnnSerializer::ResizeDescriptor> descriptor) {
8776 start_ = fbb_.StartTable();
8780 const auto end = fbb_.EndTable(start_);
8781 auto o = flatbuffers::Offset<ResizeLayer>(end);
8787 flatbuffers::FlatBufferBuilder &_fbb,
8788 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
8789 flatbuffers::Offset<armnnSerializer::ResizeDescriptor> descriptor = 0) {
8793 return builder_.
Finish();
8796 struct ResizeDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8798 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8804 VT_HALFPIXELCENTERS = 14
8822 return GetField<uint8_t>(VT_HALFPIXELCENTERS, 0) != 0;
8824 bool Verify(flatbuffers::Verifier &verifier)
const {
8825 return VerifyTableStart(verifier) &&
8828 VerifyField<int8_t>(verifier,
VT_METHOD) &&
8831 VerifyField<uint8_t>(verifier, VT_HALFPIXELCENTERS) &&
8832 verifier.EndTable();
8838 flatbuffers::FlatBufferBuilder &
fbb_;
8856 fbb_.AddElement<uint8_t>(ResizeDescriptor::VT_HALFPIXELCENTERS,
static_cast<uint8_t
>(halfPixelCenters), 0);
8860 start_ = fbb_.StartTable();
8863 flatbuffers::Offset<ResizeDescriptor>
Finish() {
8864 const auto end = fbb_.EndTable(start_);
8865 auto o = flatbuffers::Offset<ResizeDescriptor>(end);
8871 flatbuffers::FlatBufferBuilder &_fbb,
8872 uint32_t targetHeight = 0,
8873 uint32_t targetWidth = 0,
8876 bool alignCorners =
false,
8877 bool halfPixelCenters =
false) {
8885 return builder_.
Finish();
8888 struct StackLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8890 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8894 const armnnSerializer::LayerBase *
base()
const {
8895 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8898 return GetPointer<const armnnSerializer::StackDescriptor *>(
VT_DESCRIPTOR);
8900 bool Verify(flatbuffers::Verifier &verifier)
const {
8901 return VerifyTableStart(verifier) &&
8902 VerifyOffset(verifier,
VT_BASE) &&
8903 verifier.VerifyTable(base()) &&
8905 verifier.VerifyTable(descriptor()) &&
8906 verifier.EndTable();
8912 flatbuffers::FlatBufferBuilder &
fbb_;
8914 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8917 void add_descriptor(flatbuffers::Offset<armnnSerializer::StackDescriptor> descriptor) {
8922 start_ = fbb_.StartTable();
8926 const auto end = fbb_.EndTable(start_);
8927 auto o = flatbuffers::Offset<StackLayer>(end);
8933 flatbuffers::FlatBufferBuilder &_fbb,
8934 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
8935 flatbuffers::Offset<armnnSerializer::StackDescriptor> descriptor = 0) {
8939 return builder_.
Finish();
8942 struct StackDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8944 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8950 return GetField<uint32_t>(
VT_AXIS, 0);
8956 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_INPUTSHAPE);
8958 bool Verify(flatbuffers::Verifier &verifier)
const {
8959 return VerifyTableStart(verifier) &&
8960 VerifyField<uint32_t>(verifier,
VT_AXIS) &&
8962 VerifyOffset(verifier, VT_INPUTSHAPE) &&
8963 verifier.VerifyVector(inputShape()) &&
8964 verifier.EndTable();
8970 flatbuffers::FlatBufferBuilder &
fbb_;
8979 fbb_.AddOffset(StackDescriptor::VT_INPUTSHAPE, inputShape);
8983 start_ = fbb_.StartTable();
8986 flatbuffers::Offset<StackDescriptor>
Finish() {
8987 const auto end = fbb_.EndTable(start_);
8988 auto o = flatbuffers::Offset<StackDescriptor>(end);
8994 flatbuffers::FlatBufferBuilder &_fbb,
8996 uint32_t numInputs = 0,
9002 return builder_.
Finish();
9006 flatbuffers::FlatBufferBuilder &_fbb,
9008 uint32_t numInputs = 0,
9009 const std::vector<uint32_t> *inputShape =
nullptr) {
9010 auto inputShape__ = inputShape ? _fbb.CreateVector<uint32_t>(*inputShape) : 0;
9018 struct StandInDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9020 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9028 return GetField<uint32_t>(VT_NUMOUTPUTS, 0);
9030 bool Verify(flatbuffers::Verifier &verifier)
const {
9031 return VerifyTableStart(verifier) &&
9033 VerifyField<uint32_t>(verifier, VT_NUMOUTPUTS) &&
9034 verifier.EndTable();
9040 flatbuffers::FlatBufferBuilder &
fbb_;
9046 fbb_.AddElement<uint32_t>(StandInDescriptor::VT_NUMOUTPUTS, numOutputs, 0);
9050 start_ = fbb_.StartTable();
9053 flatbuffers::Offset<StandInDescriptor>
Finish() {
9054 const auto end = fbb_.EndTable(start_);
9055 auto o = flatbuffers::Offset<StandInDescriptor>(end);
9061 flatbuffers::FlatBufferBuilder &_fbb,
9062 uint32_t numInputs = 0,
9063 uint32_t numOutputs = 0) {
9067 return builder_.
Finish();
9070 struct StandInLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9072 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9076 const armnnSerializer::LayerBase *
base()
const {
9077 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9080 return GetPointer<const armnnSerializer::StandInDescriptor *>(
VT_DESCRIPTOR);
9082 bool Verify(flatbuffers::Verifier &verifier)
const {
9083 return VerifyTableStart(verifier) &&
9084 VerifyOffset(verifier,
VT_BASE) &&
9085 verifier.VerifyTable(base()) &&
9087 verifier.VerifyTable(descriptor()) &&
9088 verifier.EndTable();
9094 flatbuffers::FlatBufferBuilder &
fbb_;
9096 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9099 void add_descriptor(flatbuffers::Offset<armnnSerializer::StandInDescriptor> descriptor) {
9104 start_ = fbb_.StartTable();
9108 const auto end = fbb_.EndTable(start_);
9109 auto o = flatbuffers::Offset<StandInLayer>(end);
9115 flatbuffers::FlatBufferBuilder &_fbb,
9116 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9117 flatbuffers::Offset<armnnSerializer::StandInDescriptor> descriptor = 0) {
9121 return builder_.
Finish();
9124 struct RankLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9126 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9129 const armnnSerializer::LayerBase *
base()
const {
9130 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9132 bool Verify(flatbuffers::Verifier &verifier)
const {
9133 return VerifyTableStart(verifier) &&
9134 VerifyOffset(verifier,
VT_BASE) &&
9135 verifier.VerifyTable(base()) &&
9136 verifier.EndTable();
9142 flatbuffers::FlatBufferBuilder &
fbb_;
9144 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9149 start_ = fbb_.StartTable();
9153 const auto end = fbb_.EndTable(start_);
9154 auto o = flatbuffers::Offset<RankLayer>(end);
9160 flatbuffers::FlatBufferBuilder &_fbb,
9161 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
9164 return builder_.
Finish();
9167 struct ReduceLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9169 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9173 const armnnSerializer::LayerBase *
base()
const {
9174 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9177 return GetPointer<const armnnSerializer::ReduceDescriptor *>(
VT_DESCRIPTOR);
9179 bool Verify(flatbuffers::Verifier &verifier)
const {
9180 return VerifyTableStart(verifier) &&
9181 VerifyOffset(verifier,
VT_BASE) &&
9182 verifier.VerifyTable(base()) &&
9184 verifier.VerifyTable(descriptor()) &&
9185 verifier.EndTable();
9191 flatbuffers::FlatBufferBuilder &
fbb_;
9193 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9196 void add_descriptor(flatbuffers::Offset<armnnSerializer::ReduceDescriptor> descriptor) {
9201 start_ = fbb_.StartTable();
9205 const auto end = fbb_.EndTable(start_);
9206 auto o = flatbuffers::Offset<ReduceLayer>(end);
9212 flatbuffers::FlatBufferBuilder &_fbb,
9213 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9214 flatbuffers::Offset<armnnSerializer::ReduceDescriptor> descriptor = 0) {
9218 return builder_.
Finish();
9221 struct ReduceDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9223 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9226 VT_REDUCEOPERATION = 8
9231 const flatbuffers::Vector<uint32_t> *
axis()
const {
9232 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_AXIS);
9237 bool Verify(flatbuffers::Verifier &verifier)
const {
9238 return VerifyTableStart(verifier) &&
9240 VerifyOffset(verifier,
VT_AXIS) &&
9241 verifier.VerifyVector(axis()) &&
9242 VerifyField<int8_t>(verifier, VT_REDUCEOPERATION) &&
9243 verifier.EndTable();
9249 flatbuffers::FlatBufferBuilder &
fbb_;
9258 fbb_.AddElement<int8_t>(ReduceDescriptor::VT_REDUCEOPERATION,
static_cast<int8_t
>(reduceOperation), 0);
9262 start_ = fbb_.StartTable();
9265 flatbuffers::Offset<ReduceDescriptor>
Finish() {
9266 const auto end = fbb_.EndTable(start_);
9267 auto o = flatbuffers::Offset<ReduceDescriptor>(end);
9273 flatbuffers::FlatBufferBuilder &_fbb,
9274 bool keepDims =
false,
9281 return builder_.
Finish();
9285 flatbuffers::FlatBufferBuilder &_fbb,
9286 bool keepDims =
false,
9287 const std::vector<uint32_t> *axis =
nullptr,
9289 auto axis__ = axis ? _fbb.CreateVector<uint32_t>(*axis) : 0;
9297 struct AnyLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9299 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9307 return GetPointer<const void *>(VT_LAYER);
9309 template<
typename T>
const T *layer_as()
const;
9493 bool Verify(flatbuffers::Verifier &verifier)
const {
9494 return VerifyTableStart(verifier) &&
9496 VerifyOffset(verifier, VT_LAYER) &&
9498 verifier.EndTable();
9502 template<>
inline const armnnSerializer::ActivationLayer *AnyLayer::layer_as<armnnSerializer::ActivationLayer>()
const {
9503 return layer_as_ActivationLayer();
9506 template<>
inline const armnnSerializer::AdditionLayer *AnyLayer::layer_as<armnnSerializer::AdditionLayer>()
const {
9507 return layer_as_AdditionLayer();
9510 template<>
inline const armnnSerializer::BatchToSpaceNdLayer *AnyLayer::layer_as<armnnSerializer::BatchToSpaceNdLayer>()
const {
9511 return layer_as_BatchToSpaceNdLayer();
9514 template<>
inline const armnnSerializer::BatchNormalizationLayer *AnyLayer::layer_as<armnnSerializer::BatchNormalizationLayer>()
const {
9515 return layer_as_BatchNormalizationLayer();
9518 template<>
inline const armnnSerializer::ConstantLayer *AnyLayer::layer_as<armnnSerializer::ConstantLayer>()
const {
9519 return layer_as_ConstantLayer();
9522 template<>
inline const armnnSerializer::Convolution2dLayer *AnyLayer::layer_as<armnnSerializer::Convolution2dLayer>()
const {
9523 return layer_as_Convolution2dLayer();
9526 template<>
inline const armnnSerializer::DepthwiseConvolution2dLayer *AnyLayer::layer_as<armnnSerializer::DepthwiseConvolution2dLayer>()
const {
9527 return layer_as_DepthwiseConvolution2dLayer();
9530 template<>
inline const armnnSerializer::FullyConnectedLayer *AnyLayer::layer_as<armnnSerializer::FullyConnectedLayer>()
const {
9531 return layer_as_FullyConnectedLayer();
9534 template<>
inline const armnnSerializer::InputLayer *AnyLayer::layer_as<armnnSerializer::InputLayer>()
const {
9535 return layer_as_InputLayer();
9538 template<>
inline const armnnSerializer::MultiplicationLayer *AnyLayer::layer_as<armnnSerializer::MultiplicationLayer>()
const {
9539 return layer_as_MultiplicationLayer();
9542 template<>
inline const armnnSerializer::OutputLayer *AnyLayer::layer_as<armnnSerializer::OutputLayer>()
const {
9543 return layer_as_OutputLayer();
9546 template<>
inline const armnnSerializer::PermuteLayer *AnyLayer::layer_as<armnnSerializer::PermuteLayer>()
const {
9547 return layer_as_PermuteLayer();
9550 template<>
inline const armnnSerializer::Pooling2dLayer *AnyLayer::layer_as<armnnSerializer::Pooling2dLayer>()
const {
9551 return layer_as_Pooling2dLayer();
9554 template<>
inline const armnnSerializer::ReshapeLayer *AnyLayer::layer_as<armnnSerializer::ReshapeLayer>()
const {
9555 return layer_as_ReshapeLayer();
9558 template<>
inline const armnnSerializer::SoftmaxLayer *AnyLayer::layer_as<armnnSerializer::SoftmaxLayer>()
const {
9559 return layer_as_SoftmaxLayer();
9562 template<>
inline const armnnSerializer::SpaceToBatchNdLayer *AnyLayer::layer_as<armnnSerializer::SpaceToBatchNdLayer>()
const {
9563 return layer_as_SpaceToBatchNdLayer();
9566 template<>
inline const armnnSerializer::DivisionLayer *AnyLayer::layer_as<armnnSerializer::DivisionLayer>()
const {
9567 return layer_as_DivisionLayer();
9570 template<>
inline const armnnSerializer::MinimumLayer *AnyLayer::layer_as<armnnSerializer::MinimumLayer>()
const {
9571 return layer_as_MinimumLayer();
9574 template<>
inline const armnnSerializer::EqualLayer *AnyLayer::layer_as<armnnSerializer::EqualLayer>()
const {
9575 return layer_as_EqualLayer();
9578 template<>
inline const armnnSerializer::MaximumLayer *AnyLayer::layer_as<armnnSerializer::MaximumLayer>()
const {
9579 return layer_as_MaximumLayer();
9582 template<>
inline const armnnSerializer::NormalizationLayer *AnyLayer::layer_as<armnnSerializer::NormalizationLayer>()
const {
9583 return layer_as_NormalizationLayer();
9586 template<>
inline const armnnSerializer::PadLayer *AnyLayer::layer_as<armnnSerializer::PadLayer>()
const {
9587 return layer_as_PadLayer();
9590 template<>
inline const armnnSerializer::RsqrtLayer *AnyLayer::layer_as<armnnSerializer::RsqrtLayer>()
const {
9591 return layer_as_RsqrtLayer();
9594 template<>
inline const armnnSerializer::FloorLayer *AnyLayer::layer_as<armnnSerializer::FloorLayer>()
const {
9595 return layer_as_FloorLayer();
9598 template<>
inline const armnnSerializer::GreaterLayer *AnyLayer::layer_as<armnnSerializer::GreaterLayer>()
const {
9599 return layer_as_GreaterLayer();
9602 template<>
inline const armnnSerializer::ResizeBilinearLayer *AnyLayer::layer_as<armnnSerializer::ResizeBilinearLayer>()
const {
9603 return layer_as_ResizeBilinearLayer();
9606 template<>
inline const armnnSerializer::SubtractionLayer *AnyLayer::layer_as<armnnSerializer::SubtractionLayer>()
const {
9607 return layer_as_SubtractionLayer();
9610 template<>
inline const armnnSerializer::StridedSliceLayer *AnyLayer::layer_as<armnnSerializer::StridedSliceLayer>()
const {
9611 return layer_as_StridedSliceLayer();
9614 template<>
inline const armnnSerializer::GatherLayer *AnyLayer::layer_as<armnnSerializer::GatherLayer>()
const {
9615 return layer_as_GatherLayer();
9618 template<>
inline const armnnSerializer::MeanLayer *AnyLayer::layer_as<armnnSerializer::MeanLayer>()
const {
9619 return layer_as_MeanLayer();
9623 return layer_as_MergerLayer();
9626 template<>
inline const armnnSerializer::L2NormalizationLayer *AnyLayer::layer_as<armnnSerializer::L2NormalizationLayer>()
const {
9627 return layer_as_L2NormalizationLayer();
9630 template<>
inline const armnnSerializer::SplitterLayer *AnyLayer::layer_as<armnnSerializer::SplitterLayer>()
const {
9631 return layer_as_SplitterLayer();
9634 template<>
inline const armnnSerializer::DetectionPostProcessLayer *AnyLayer::layer_as<armnnSerializer::DetectionPostProcessLayer>()
const {
9635 return layer_as_DetectionPostProcessLayer();
9638 template<>
inline const armnnSerializer::LstmLayer *AnyLayer::layer_as<armnnSerializer::LstmLayer>()
const {
9639 return layer_as_LstmLayer();
9642 template<>
inline const armnnSerializer::QuantizedLstmLayer *AnyLayer::layer_as<armnnSerializer::QuantizedLstmLayer>()
const {
9643 return layer_as_QuantizedLstmLayer();
9646 template<>
inline const armnnSerializer::QuantizeLayer *AnyLayer::layer_as<armnnSerializer::QuantizeLayer>()
const {
9647 return layer_as_QuantizeLayer();
9650 template<>
inline const armnnSerializer::DequantizeLayer *AnyLayer::layer_as<armnnSerializer::DequantizeLayer>()
const {
9651 return layer_as_DequantizeLayer();
9654 template<>
inline const armnnSerializer::MergeLayer *AnyLayer::layer_as<armnnSerializer::MergeLayer>()
const {
9655 return layer_as_MergeLayer();
9658 template<>
inline const armnnSerializer::SwitchLayer *AnyLayer::layer_as<armnnSerializer::SwitchLayer>()
const {
9659 return layer_as_SwitchLayer();
9662 template<>
inline const armnnSerializer::ConcatLayer *AnyLayer::layer_as<armnnSerializer::ConcatLayer>()
const {
9663 return layer_as_ConcatLayer();
9666 template<>
inline const armnnSerializer::SpaceToDepthLayer *AnyLayer::layer_as<armnnSerializer::SpaceToDepthLayer>()
const {
9667 return layer_as_SpaceToDepthLayer();
9670 template<>
inline const armnnSerializer::PreluLayer *AnyLayer::layer_as<armnnSerializer::PreluLayer>()
const {
9671 return layer_as_PreluLayer();
9674 template<>
inline const armnnSerializer::TransposeConvolution2dLayer *AnyLayer::layer_as<armnnSerializer::TransposeConvolution2dLayer>()
const {
9675 return layer_as_TransposeConvolution2dLayer();
9678 template<>
inline const armnnSerializer::ResizeLayer *AnyLayer::layer_as<armnnSerializer::ResizeLayer>()
const {
9679 return layer_as_ResizeLayer();
9682 template<>
inline const armnnSerializer::StackLayer *AnyLayer::layer_as<armnnSerializer::StackLayer>()
const {
9683 return layer_as_StackLayer();
9686 template<>
inline const armnnSerializer::AbsLayer *AnyLayer::layer_as<armnnSerializer::AbsLayer>()
const {
9687 return layer_as_AbsLayer();
9690 template<>
inline const armnnSerializer::ArgMinMaxLayer *AnyLayer::layer_as<armnnSerializer::ArgMinMaxLayer>()
const {
9691 return layer_as_ArgMinMaxLayer();
9694 template<>
inline const armnnSerializer::SliceLayer *AnyLayer::layer_as<armnnSerializer::SliceLayer>()
const {
9695 return layer_as_SliceLayer();
9698 template<>
inline const armnnSerializer::DepthToSpaceLayer *AnyLayer::layer_as<armnnSerializer::DepthToSpaceLayer>()
const {
9699 return layer_as_DepthToSpaceLayer();
9702 template<>
inline const armnnSerializer::InstanceNormalizationLayer *AnyLayer::layer_as<armnnSerializer::InstanceNormalizationLayer>()
const {
9703 return layer_as_InstanceNormalizationLayer();
9706 template<>
inline const armnnSerializer::LogSoftmaxLayer *AnyLayer::layer_as<armnnSerializer::LogSoftmaxLayer>()
const {
9707 return layer_as_LogSoftmaxLayer();
9710 template<>
inline const armnnSerializer::ComparisonLayer *AnyLayer::layer_as<armnnSerializer::ComparisonLayer>()
const {
9711 return layer_as_ComparisonLayer();
9714 template<>
inline const armnnSerializer::StandInLayer *AnyLayer::layer_as<armnnSerializer::StandInLayer>()
const {
9715 return layer_as_StandInLayer();
9718 template<>
inline const armnnSerializer::ElementwiseUnaryLayer *AnyLayer::layer_as<armnnSerializer::ElementwiseUnaryLayer>()
const {
9719 return layer_as_ElementwiseUnaryLayer();
9722 template<>
inline const armnnSerializer::TransposeLayer *AnyLayer::layer_as<armnnSerializer::TransposeLayer>()
const {
9723 return layer_as_TransposeLayer();
9726 template<>
inline const armnnSerializer::QLstmLayer *AnyLayer::layer_as<armnnSerializer::QLstmLayer>()
const {
9727 return layer_as_QLstmLayer();
9730 template<>
inline const armnnSerializer::FillLayer *AnyLayer::layer_as<armnnSerializer::FillLayer>()
const {
9731 return layer_as_FillLayer();
9734 template<>
inline const armnnSerializer::RankLayer *AnyLayer::layer_as<armnnSerializer::RankLayer>()
const {
9735 return layer_as_RankLayer();
9738 template<>
inline const armnnSerializer::LogicalBinaryLayer *AnyLayer::layer_as<armnnSerializer::LogicalBinaryLayer>()
const {
9739 return layer_as_LogicalBinaryLayer();
9742 template<>
inline const armnnSerializer::ReduceLayer *AnyLayer::layer_as<armnnSerializer::ReduceLayer>()
const {
9743 return layer_as_ReduceLayer();
9748 flatbuffers::FlatBufferBuilder &
fbb_;
9754 fbb_.AddOffset(AnyLayer::VT_LAYER, layer);
9758 start_ = fbb_.StartTable();
9762 const auto end = fbb_.EndTable(start_);
9763 auto o = flatbuffers::Offset<AnyLayer>(end);
9769 flatbuffers::FlatBufferBuilder &_fbb,
9771 flatbuffers::Offset<void> layer = 0) {
9775 return builder_.
Finish();
9778 struct FeatureCompatibilityVersions FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9780 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9781 VT_BINDINGIDSSCHEME = 4
9784 return GetField<uint32_t>(VT_BINDINGIDSSCHEME, 0);
9786 bool Verify(flatbuffers::Verifier &verifier)
const {
9787 return VerifyTableStart(verifier) &&
9788 VerifyField<uint32_t>(verifier, VT_BINDINGIDSSCHEME) &&
9789 verifier.EndTable();
9794 typedef FeatureCompatibilityVersions
Table;
9795 flatbuffers::FlatBufferBuilder &
fbb_;
9798 fbb_.AddElement<uint32_t>(FeatureCompatibilityVersions::VT_BINDINGIDSSCHEME, bindingIdsScheme, 0);
9802 start_ = fbb_.StartTable();
9805 flatbuffers::Offset<FeatureCompatibilityVersions>
Finish() {
9806 const auto end = fbb_.EndTable(start_);
9807 auto o = flatbuffers::Offset<FeatureCompatibilityVersions>(end);
9813 flatbuffers::FlatBufferBuilder &_fbb,
9814 uint32_t bindingIdsScheme = 0) {
9817 return builder_.
Finish();
9820 struct SerializedGraph FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9822 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9826 VT_FEATUREVERSIONS = 10
9828 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::AnyLayer>> *
layers()
const {
9829 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::AnyLayer>> *>(
VT_LAYERS);
9832 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_INPUTIDS);
9835 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_OUTPUTIDS);
9838 return GetPointer<const armnnSerializer::FeatureCompatibilityVersions *>(VT_FEATUREVERSIONS);
9840 bool Verify(flatbuffers::Verifier &verifier)
const {
9841 return VerifyTableStart(verifier) &&
9843 verifier.VerifyVector(layers()) &&
9844 verifier.VerifyVectorOfTables(layers()) &&
9846 verifier.VerifyVector(inputIds()) &&
9848 verifier.VerifyVector(outputIds()) &&
9849 VerifyOffset(verifier, VT_FEATUREVERSIONS) &&
9850 verifier.VerifyTable(featureVersions()) &&
9851 verifier.EndTable();
9857 flatbuffers::FlatBufferBuilder &
fbb_;
9868 void add_featureVersions(flatbuffers::Offset<armnnSerializer::FeatureCompatibilityVersions> featureVersions) {
9869 fbb_.AddOffset(SerializedGraph::VT_FEATUREVERSIONS, featureVersions);
9873 start_ = fbb_.StartTable();
9876 flatbuffers::Offset<SerializedGraph>
Finish() {
9877 const auto end = fbb_.EndTable(start_);
9878 auto o = flatbuffers::Offset<SerializedGraph>(end);
9884 flatbuffers::FlatBufferBuilder &_fbb,
9885 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::AnyLayer>>> layers = 0,
9888 flatbuffers::Offset<armnnSerializer::FeatureCompatibilityVersions> featureVersions = 0) {
9894 return builder_.
Finish();
9898 flatbuffers::FlatBufferBuilder &_fbb,
9899 const std::vector<flatbuffers::Offset<armnnSerializer::AnyLayer>> *layers =
nullptr,
9900 const std::vector<int32_t> *inputIds =
nullptr,
9901 const std::vector<int32_t> *outputIds =
nullptr,
9902 flatbuffers::Offset<armnnSerializer::FeatureCompatibilityVersions> featureVersions = 0) {
9903 auto layers__ = layers ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::AnyLayer>>(*layers) : 0;
9904 auto inputIds__ = inputIds ? _fbb.CreateVector<int32_t>(*inputIds) : 0;
9905 auto outputIds__ = outputIds ? _fbb.CreateVector<int32_t>(*outputIds) : 0;
9920 auto ptr =
reinterpret_cast<const armnnSerializer::ByteData *
>(obj);
9921 return verifier.VerifyTable(ptr);
9924 auto ptr =
reinterpret_cast<const armnnSerializer::ShortData *
>(obj);
9925 return verifier.VerifyTable(ptr);
9928 auto ptr =
reinterpret_cast<const armnnSerializer::IntData *
>(obj);
9929 return verifier.VerifyTable(ptr);
9932 auto ptr =
reinterpret_cast<const armnnSerializer::LongData *
>(obj);
9933 return verifier.VerifyTable(ptr);
9935 default:
return true;
9939 inline bool VerifyConstTensorDataVector(flatbuffers::Verifier &verifier,
const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
const flatbuffers::Vector<uint8_t> *types) {
9940 if (!values || !types)
return !values && !types;
9941 if (values->size() != types->size())
return false;
9942 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
9957 auto ptr =
reinterpret_cast<const armnnSerializer::ActivationLayer *
>(obj);
9958 return verifier.VerifyTable(ptr);
9961 auto ptr =
reinterpret_cast<const armnnSerializer::AdditionLayer *
>(obj);
9962 return verifier.VerifyTable(ptr);
9965 auto ptr =
reinterpret_cast<const armnnSerializer::BatchToSpaceNdLayer *
>(obj);
9966 return verifier.VerifyTable(ptr);
9969 auto ptr =
reinterpret_cast<const armnnSerializer::BatchNormalizationLayer *
>(obj);
9970 return verifier.VerifyTable(ptr);
9973 auto ptr =
reinterpret_cast<const armnnSerializer::ConstantLayer *
>(obj);
9974 return verifier.VerifyTable(ptr);
9977 auto ptr =
reinterpret_cast<const armnnSerializer::Convolution2dLayer *
>(obj);
9978 return verifier.VerifyTable(ptr);
9981 auto ptr =
reinterpret_cast<const armnnSerializer::DepthwiseConvolution2dLayer *
>(obj);
9982 return verifier.VerifyTable(ptr);
9985 auto ptr =
reinterpret_cast<const armnnSerializer::FullyConnectedLayer *
>(obj);
9986 return verifier.VerifyTable(ptr);
9989 auto ptr =
reinterpret_cast<const armnnSerializer::InputLayer *
>(obj);
9990 return verifier.VerifyTable(ptr);
9993 auto ptr =
reinterpret_cast<const armnnSerializer::MultiplicationLayer *
>(obj);
9994 return verifier.VerifyTable(ptr);
9997 auto ptr =
reinterpret_cast<const armnnSerializer::OutputLayer *
>(obj);
9998 return verifier.VerifyTable(ptr);
10001 auto ptr =
reinterpret_cast<const armnnSerializer::PermuteLayer *
>(obj);
10002 return verifier.VerifyTable(ptr);
10005 auto ptr =
reinterpret_cast<const armnnSerializer::Pooling2dLayer *
>(obj);
10006 return verifier.VerifyTable(ptr);
10009 auto ptr =
reinterpret_cast<const armnnSerializer::ReshapeLayer *
>(obj);
10010 return verifier.VerifyTable(ptr);
10013 auto ptr =
reinterpret_cast<const armnnSerializer::SoftmaxLayer *
>(obj);
10014 return verifier.VerifyTable(ptr);
10017 auto ptr =
reinterpret_cast<const armnnSerializer::SpaceToBatchNdLayer *
>(obj);
10018 return verifier.VerifyTable(ptr);
10021 auto ptr =
reinterpret_cast<const armnnSerializer::DivisionLayer *
>(obj);
10022 return verifier.VerifyTable(ptr);
10025 auto ptr =
reinterpret_cast<const armnnSerializer::MinimumLayer *
>(obj);
10026 return verifier.VerifyTable(ptr);
10029 auto ptr =
reinterpret_cast<const armnnSerializer::EqualLayer *
>(obj);
10030 return verifier.VerifyTable(ptr);
10033 auto ptr =
reinterpret_cast<const armnnSerializer::MaximumLayer *
>(obj);
10034 return verifier.VerifyTable(ptr);
10037 auto ptr =
reinterpret_cast<const armnnSerializer::NormalizationLayer *
>(obj);
10038 return verifier.VerifyTable(ptr);
10041 auto ptr =
reinterpret_cast<const armnnSerializer::PadLayer *
>(obj);
10042 return verifier.VerifyTable(ptr);
10045 auto ptr =
reinterpret_cast<const armnnSerializer::RsqrtLayer *
>(obj);
10046 return verifier.VerifyTable(ptr);
10049 auto ptr =
reinterpret_cast<const armnnSerializer::FloorLayer *
>(obj);
10050 return verifier.VerifyTable(ptr);
10053 auto ptr =
reinterpret_cast<const armnnSerializer::GreaterLayer *
>(obj);
10054 return verifier.VerifyTable(ptr);
10057 auto ptr =
reinterpret_cast<const armnnSerializer::ResizeBilinearLayer *
>(obj);
10058 return verifier.VerifyTable(ptr);
10061 auto ptr =
reinterpret_cast<const armnnSerializer::SubtractionLayer *
>(obj);
10062 return verifier.VerifyTable(ptr);
10065 auto ptr =
reinterpret_cast<const armnnSerializer::StridedSliceLayer *
>(obj);
10066 return verifier.VerifyTable(ptr);
10069 auto ptr =
reinterpret_cast<const armnnSerializer::GatherLayer *
>(obj);
10070 return verifier.VerifyTable(ptr);
10073 auto ptr =
reinterpret_cast<const armnnSerializer::MeanLayer *
>(obj);
10074 return verifier.VerifyTable(ptr);
10078 return verifier.VerifyTable(ptr);
10081 auto ptr =
reinterpret_cast<const armnnSerializer::L2NormalizationLayer *
>(obj);
10082 return verifier.VerifyTable(ptr);
10085 auto ptr =
reinterpret_cast<const armnnSerializer::SplitterLayer *
>(obj);
10086 return verifier.VerifyTable(ptr);
10089 auto ptr =
reinterpret_cast<const armnnSerializer::DetectionPostProcessLayer *
>(obj);
10090 return verifier.VerifyTable(ptr);
10093 auto ptr =
reinterpret_cast<const armnnSerializer::LstmLayer *
>(obj);
10094 return verifier.VerifyTable(ptr);
10097 auto ptr =
reinterpret_cast<const armnnSerializer::QuantizedLstmLayer *
>(obj);
10098 return verifier.VerifyTable(ptr);
10101 auto ptr =
reinterpret_cast<const armnnSerializer::QuantizeLayer *
>(obj);
10102 return verifier.VerifyTable(ptr);
10105 auto ptr =
reinterpret_cast<const armnnSerializer::DequantizeLayer *
>(obj);
10106 return verifier.VerifyTable(ptr);
10109 auto ptr =
reinterpret_cast<const armnnSerializer::MergeLayer *
>(obj);
10110 return verifier.VerifyTable(ptr);
10113 auto ptr =
reinterpret_cast<const armnnSerializer::SwitchLayer *
>(obj);
10114 return verifier.VerifyTable(ptr);
10117 auto ptr =
reinterpret_cast<const armnnSerializer::ConcatLayer *
>(obj);
10118 return verifier.VerifyTable(ptr);
10121 auto ptr =
reinterpret_cast<const armnnSerializer::SpaceToDepthLayer *
>(obj);
10122 return verifier.VerifyTable(ptr);
10125 auto ptr =
reinterpret_cast<const armnnSerializer::PreluLayer *
>(obj);
10126 return verifier.VerifyTable(ptr);
10129 auto ptr =
reinterpret_cast<const armnnSerializer::TransposeConvolution2dLayer *
>(obj);
10130 return verifier.VerifyTable(ptr);
10133 auto ptr =
reinterpret_cast<const armnnSerializer::ResizeLayer *
>(obj);
10134 return verifier.VerifyTable(ptr);
10137 auto ptr =
reinterpret_cast<const armnnSerializer::StackLayer *
>(obj);
10138 return verifier.VerifyTable(ptr);
10141 auto ptr =
reinterpret_cast<const armnnSerializer::AbsLayer *
>(obj);
10142 return verifier.VerifyTable(ptr);
10145 auto ptr =
reinterpret_cast<const armnnSerializer::ArgMinMaxLayer *
>(obj);
10146 return verifier.VerifyTable(ptr);
10149 auto ptr =
reinterpret_cast<const armnnSerializer::SliceLayer *
>(obj);
10150 return verifier.VerifyTable(ptr);
10153 auto ptr =
reinterpret_cast<const armnnSerializer::DepthToSpaceLayer *
>(obj);
10154 return verifier.VerifyTable(ptr);
10157 auto ptr =
reinterpret_cast<const armnnSerializer::InstanceNormalizationLayer *
>(obj);
10158 return verifier.VerifyTable(ptr);
10161 auto ptr =
reinterpret_cast<const armnnSerializer::LogSoftmaxLayer *
>(obj);
10162 return verifier.VerifyTable(ptr);
10165 auto ptr =
reinterpret_cast<const armnnSerializer::ComparisonLayer *
>(obj);
10166 return verifier.VerifyTable(ptr);
10169 auto ptr =
reinterpret_cast<const armnnSerializer::StandInLayer *
>(obj);
10170 return verifier.VerifyTable(ptr);
10173 auto ptr =
reinterpret_cast<const armnnSerializer::ElementwiseUnaryLayer *
>(obj);
10174 return verifier.VerifyTable(ptr);
10177 auto ptr =
reinterpret_cast<const armnnSerializer::TransposeLayer *
>(obj);
10178 return verifier.VerifyTable(ptr);
10181 auto ptr =
reinterpret_cast<const armnnSerializer::QLstmLayer *
>(obj);
10182 return verifier.VerifyTable(ptr);
10185 auto ptr =
reinterpret_cast<const armnnSerializer::FillLayer *
>(obj);
10186 return verifier.VerifyTable(ptr);
10189 auto ptr =
reinterpret_cast<const armnnSerializer::RankLayer *
>(obj);
10190 return verifier.VerifyTable(ptr);
10193 auto ptr =
reinterpret_cast<const armnnSerializer::LogicalBinaryLayer *
>(obj);
10194 return verifier.VerifyTable(ptr);
10197 auto ptr =
reinterpret_cast<const armnnSerializer::ReduceLayer *
>(obj);
10198 return verifier.VerifyTable(ptr);
10200 default:
return true;
10204 inline bool VerifyLayerVector(flatbuffers::Verifier &verifier,
const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
const flatbuffers::Vector<uint8_t> *types) {
10205 if (!values || !types)
return !values && !types;
10206 if (values->size() != types->size())
return false;
10207 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
10209 verifier, values->Get(i), types->GetEnum<
Layer>(i))) {
10217 return flatbuffers::GetRoot<armnnSerializer::SerializedGraph>(buf);
10221 return flatbuffers::GetSizePrefixedRoot<armnnSerializer::SerializedGraph>(buf);
10229 return flatbuffers::BufferHasIdentifier(
10234 flatbuffers::Verifier &verifier) {
10239 flatbuffers::Verifier &verifier) {
10248 flatbuffers::FlatBufferBuilder &fbb,
10249 flatbuffers::Offset<armnnSerializer::SerializedGraph> root) {
10254 flatbuffers::FlatBufferBuilder &fbb,
10255 flatbuffers::Offset<armnnSerializer::SerializedGraph> root) {
10261 #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)
flatbuffers::Offset< MeanLayer > 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)
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)
flatbuffers::Offset< FullyConnectedDescriptor > CreateFullyConnectedDescriptor(flatbuffers::FlatBufferBuilder &_fbb, bool biasEnabled=false, bool transposeWeightsMatrix=false)
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
flatbuffers::FlatBufferBuilder & fbb_
void add_maxClassesPerDetection(uint32_t maxClassesPerDetection)
void add_dilationY(uint32_t dilationY)
const armnnSerializer::PermuteLayer * layer_as_PermuteLayer() const
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)
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)
const UnaryOperation(& EnumValuesUnaryOperation())[6]
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()
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_
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()
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()
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)
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_
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)
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_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)
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]
const DataType(& EnumValuesDataType())[10]
StridedSliceLayerBuilder Builder
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::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()
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_
const LayerType(& EnumValuesLayerType())[61]
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
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()
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::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< 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_data(flatbuffers::Offset< flatbuffers::Vector< int32_t >> data)
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)
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_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::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::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()
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)
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)
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)
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)
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
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)
DetectionPostProcessDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::DepthToSpaceDescriptor * descriptor() const
MaximumLayerBuilder Builder
flatbuffers::uoffset_t start_
PadDescriptorBuilder Builder
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
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::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)
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_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)
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_
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 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
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_
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)
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)
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_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()
SpaceToBatchNdLayerBuilder Builder
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)
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)
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 Layer(& EnumValuesLayer())[62]
const armnnSerializer::StandInDescriptor * descriptor() const
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)
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)
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_
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_
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)
flatbuffers::Offset< FeatureCompatibilityVersions > CreateFeatureCompatibilityVersions(flatbuffers::FlatBufferBuilder &_fbb, uint32_t bindingIdsScheme=0)
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::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_
flatbuffers::Offset< PadDescriptor > CreatePadDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint32_t > *padList=nullptr, float padValue=0.0f)
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
ShortDataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const char *const * EnumNamesUnaryOperation()
void add_inputParams(flatbuffers::Offset< armnnSerializer::LstmInputParams > inputParams)
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)
std::vector< float > anchors({ 0.5f, 0.5f, 1.0f, 1.0f, 0.5f, 0.5f, 1.0f, 1.0f, 0.5f, 0.5f, 1.0f, 1.0f, 0.5f, 10.5f, 1.0f, 1.0f, 0.5f, 10.5f, 1.0f, 1.0f, 0.5f, 100.5f, 1.0f, 1.0f })
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)