7 #ifndef FLATBUFFERS_GENERATED_ARMNNSCHEMA_ARMNNSERIALIZER_H_ 8 #define FLATBUFFERS_GENERATED_ARMNNSCHEMA_ARMNNSERIALIZER_H_ 10 #include "flatbuffers/flatbuffers.h" 15 struct TensorInfoBuilder;
20 struct ByteDataBuilder;
23 struct ShortDataBuilder;
26 struct IntDataBuilder;
29 struct LongDataBuilder;
32 struct ConstTensorBuilder;
35 struct InputSlotBuilder;
38 struct OutputSlotBuilder;
41 struct LayerBaseBuilder;
43 struct BindableLayerBase;
44 struct BindableLayerBaseBuilder;
47 struct AbsLayerBuilder;
49 struct ActivationLayer;
50 struct ActivationLayerBuilder;
52 struct ActivationDescriptor;
53 struct ActivationDescriptorBuilder;
56 struct AdditionLayerBuilder;
58 struct ArgMinMaxLayer;
59 struct ArgMinMaxLayerBuilder;
61 struct ArgMinMaxDescriptor;
62 struct ArgMinMaxDescriptorBuilder;
65 struct CastLayerBuilder;
67 struct ComparisonDescriptor;
68 struct ComparisonDescriptorBuilder;
70 struct ComparisonLayer;
71 struct ComparisonLayerBuilder;
74 struct ConstantLayerBuilder;
76 struct Convolution2dLayer;
77 struct Convolution2dLayerBuilder;
79 struct Convolution2dDescriptor;
80 struct Convolution2dDescriptorBuilder;
82 struct DepthToSpaceLayer;
83 struct DepthToSpaceLayerBuilder;
86 struct DepthToSpaceDescriptorBuilder;
89 struct DivisionLayerBuilder;
91 struct ElementwiseUnaryDescriptor;
92 struct ElementwiseUnaryDescriptorBuilder;
94 struct ElementwiseUnaryLayer;
95 struct ElementwiseUnaryLayerBuilder;
98 struct EqualLayerBuilder;
101 struct FillLayerBuilder;
103 struct FillDescriptor;
104 struct FillDescriptorBuilder;
107 struct FloorLayerBuilder;
109 struct FullyConnectedLayer;
110 struct FullyConnectedLayerBuilder;
112 struct FullyConnectedDescriptor;
113 struct FullyConnectedDescriptorBuilder;
116 struct GatherLayerBuilder;
118 struct GatherDescriptor;
119 struct GatherDescriptorBuilder;
122 struct GreaterLayerBuilder;
125 struct InputLayerBuilder;
127 struct InstanceNormalizationLayer;
128 struct InstanceNormalizationLayerBuilder;
130 struct InstanceNormalizationDescriptor;
131 struct InstanceNormalizationDescriptorBuilder;
133 struct LogSoftmaxLayer;
134 struct LogSoftmaxLayerBuilder;
137 struct LogSoftmaxDescriptorBuilder;
139 struct L2NormalizationLayer;
140 struct L2NormalizationLayerBuilder;
142 struct L2NormalizationDescriptor;
143 struct L2NormalizationDescriptorBuilder;
145 struct LogicalBinaryDescriptor;
146 struct LogicalBinaryDescriptorBuilder;
148 struct LogicalBinaryLayer;
149 struct LogicalBinaryLayerBuilder;
152 struct MinimumLayerBuilder;
155 struct MaximumLayerBuilder;
157 struct MultiplicationLayer;
158 struct MultiplicationLayerBuilder;
160 struct Pooling2dLayer;
161 struct Pooling2dLayerBuilder;
163 struct Pooling2dDescriptor;
164 struct Pooling2dDescriptorBuilder;
166 struct QuantizeLayer;
167 struct QuantizeLayerBuilder;
170 struct SoftmaxLayerBuilder;
172 struct SoftmaxDescriptor;
173 struct SoftmaxDescriptorBuilder;
175 struct DepthwiseConvolution2dLayer;
176 struct DepthwiseConvolution2dLayerBuilder;
178 struct DepthwiseConvolution2dDescriptor;
179 struct DepthwiseConvolution2dDescriptorBuilder;
182 struct OutputLayerBuilder;
185 struct ReshapeLayerBuilder;
187 struct ReshapeDescriptor;
188 struct ReshapeDescriptorBuilder;
191 struct PermuteLayerBuilder;
193 struct PermuteDescriptor;
194 struct PermuteDescriptorBuilder;
196 struct SpaceToBatchNdLayer;
197 struct SpaceToBatchNdLayerBuilder;
199 struct SpaceToBatchNdDescriptor;
200 struct SpaceToBatchNdDescriptorBuilder;
202 struct SpaceToDepthLayer;
203 struct SpaceToDepthLayerBuilder;
205 struct SpaceToDepthDescriptor;
206 struct SpaceToDepthDescriptorBuilder;
208 struct SubtractionLayer;
209 struct SubtractionLayerBuilder;
211 struct BatchToSpaceNdLayer;
212 struct BatchToSpaceNdLayerBuilder;
214 struct BatchToSpaceNdDescriptor;
215 struct BatchToSpaceNdDescriptorBuilder;
217 struct NormalizationLayer;
218 struct NormalizationLayerBuilder;
220 struct NormalizationDescriptor;
221 struct NormalizationDescriptorBuilder;
224 struct MeanLayerBuilder;
226 struct MeanDescriptor;
227 struct MeanDescriptorBuilder;
230 struct PadLayerBuilder;
232 struct PadDescriptor;
233 struct PadDescriptorBuilder;
236 struct RsqrtLayerBuilder;
238 struct BatchNormalizationLayer;
239 struct BatchNormalizationLayerBuilder;
241 struct BatchNormalizationDescriptor;
242 struct BatchNormalizationDescriptorBuilder;
244 struct ResizeBilinearLayer;
245 struct ResizeBilinearLayerBuilder;
247 struct ResizeBilinearDescriptor;
248 struct ResizeBilinearDescriptorBuilder;
251 struct SliceLayerBuilder;
253 struct SliceDescriptor;
254 struct SliceDescriptorBuilder;
256 struct StridedSliceLayer;
257 struct StridedSliceLayerBuilder;
259 struct StridedSliceDescriptor;
260 struct StridedSliceDescriptorBuilder;
263 struct ConcatLayerBuilder;
266 struct MergerLayerBuilder;
269 struct UintVectorBuilder;
271 struct OriginsDescriptor;
272 struct OriginsDescriptorBuilder;
274 struct ViewsDescriptor;
275 struct ViewsDescriptorBuilder;
277 struct SplitterLayer;
278 struct SplitterLayerBuilder;
280 struct DetectionPostProcessLayer;
281 struct DetectionPostProcessLayerBuilder;
283 struct DetectionPostProcessDescriptor;
284 struct DetectionPostProcessDescriptorBuilder;
286 struct LstmInputParams;
287 struct LstmInputParamsBuilder;
289 struct LstmDescriptor;
290 struct LstmDescriptorBuilder;
293 struct LstmLayerBuilder;
295 struct QLstmInputParams;
296 struct QLstmInputParamsBuilder;
298 struct QLstmDescriptor;
299 struct QLstmDescriptorBuilder;
302 struct QLstmLayerBuilder;
304 struct QuantizedLstmInputParams;
305 struct QuantizedLstmInputParamsBuilder;
307 struct QuantizedLstmLayer;
308 struct QuantizedLstmLayerBuilder;
310 struct DequantizeLayer;
311 struct DequantizeLayerBuilder;
314 struct MergeLayerBuilder;
317 struct SwitchLayerBuilder;
320 struct PreluLayerBuilder;
322 struct TransposeConvolution2dLayer;
323 struct TransposeConvolution2dLayerBuilder;
325 struct TransposeConvolution2dDescriptor;
326 struct TransposeConvolution2dDescriptorBuilder;
328 struct TransposeLayer;
329 struct TransposeLayerBuilder;
331 struct TransposeDescriptor;
332 struct TransposeDescriptorBuilder;
335 struct ResizeLayerBuilder;
337 struct ResizeDescriptor;
338 struct ResizeDescriptorBuilder;
341 struct StackLayerBuilder;
343 struct StackDescriptor;
344 struct StackDescriptorBuilder;
346 struct StandInDescriptor;
347 struct StandInDescriptorBuilder;
350 struct StandInLayerBuilder;
353 struct RankLayerBuilder;
356 struct ReduceLayerBuilder;
358 struct ReduceDescriptor;
359 struct ReduceDescriptorBuilder;
362 struct AnyLayerBuilder;
364 struct FeatureCompatibilityVersions;
365 struct FeatureCompatibilityVersionsBuilder;
367 struct SerializedGraph;
368 struct SerializedGraphBuilder;
406 static const char *
const names[13] = {
426 const size_t index =
static_cast<size_t>(e);
446 static const char *
const names[3] = {
456 const size_t index =
static_cast<size_t>(e);
494 static const char *
const names[12] = {
513 const size_t index =
static_cast<size_t>(e);
533 static const char *
const names[3] = {
543 const size_t index =
static_cast<size_t>(e);
567 static const char *
const names[5] = {
579 const size_t index =
static_cast<size_t>(e);
599 static const char *
const names[3] = {
609 const size_t index =
static_cast<size_t>(e);
635 static const char *
const names[6] = {
648 const size_t index =
static_cast<size_t>(e);
673 bool VerifyConstTensorDataVector(flatbuffers::Verifier &verifier,
const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
const flatbuffers::Vector<uint8_t> *types);
811 static const char *
const names[63] = {
820 "DepthwiseConvolution2d",
835 "BatchNormalization",
845 "DetectionPostProcess",
854 "TransposeConvolution2d",
862 "InstanceNormalization",
881 const size_t index =
static_cast<size_t>(e);
909 static const char *
const names[7] = {
923 const size_t index =
static_cast<size_t>(e);
951 static const char *
const names[7] = {
965 const size_t index =
static_cast<size_t>(e);
985 static const char *
const names[3] = {
995 const size_t index =
static_cast<size_t>(e);
1017 static const char *
const names[4] = {
1028 const size_t index =
static_cast<size_t>(e);
1048 static const char *
const names[3] = {
1058 const size_t index =
static_cast<size_t>(e);
1078 static const char *
const names[3] = {
1088 const size_t index =
static_cast<size_t>(e);
1108 static const char *
const names[3] = {
1118 const size_t index =
static_cast<size_t>(e);
1138 static const char *
const names[3] = {
1148 const size_t index =
static_cast<size_t>(e);
1221 static const Layer values[] = {
1290 static const char *
const names[64] = {
1294 "BatchToSpaceNdLayer",
1295 "BatchNormalizationLayer",
1297 "Convolution2dLayer",
1298 "DepthwiseConvolution2dLayer",
1299 "FullyConnectedLayer",
1301 "MultiplicationLayer",
1307 "SpaceToBatchNdLayer",
1312 "NormalizationLayer",
1317 "ResizeBilinearLayer",
1319 "StridedSliceLayer",
1323 "L2NormalizationLayer",
1325 "DetectionPostProcessLayer",
1327 "QuantizedLstmLayer",
1333 "SpaceToDepthLayer",
1335 "TransposeConvolution2dLayer",
1341 "DepthToSpaceLayer",
1342 "InstanceNormalizationLayer",
1346 "ElementwiseUnaryLayer",
1351 "LogicalBinaryLayer",
1361 const size_t index =
static_cast<size_t>(e);
1617 bool VerifyLayer(flatbuffers::Verifier &verifier,
const void *obj,
Layer type);
1618 bool VerifyLayerVector(flatbuffers::Verifier &verifier,
const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
const flatbuffers::Vector<uint8_t> *types);
1622 uint32_t sourceLayerIndex_;
1623 uint32_t outputSlotIndex_;
1627 memset(static_cast<void *>(
this), 0,
sizeof(Connection));
1629 Connection(uint32_t _sourceLayerIndex, uint32_t _outputSlotIndex)
1630 : sourceLayerIndex_(flatbuffers::EndianScalar(_sourceLayerIndex)),
1631 outputSlotIndex_(flatbuffers::EndianScalar(_outputSlotIndex)) {
1633 uint32_t sourceLayerIndex()
const {
1634 return flatbuffers::EndianScalar(sourceLayerIndex_);
1636 uint32_t outputSlotIndex()
const {
1637 return flatbuffers::EndianScalar(outputSlotIndex_);
1644 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1652 VT_DIMENSIONSPECIFICITY = 18
1655 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_DIMENSIONS);
1676 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DIMENSIONSPECIFICITY);
1678 bool Verify(flatbuffers::Verifier &verifier)
const {
1679 return VerifyTableStart(verifier) &&
1681 verifier.VerifyVector(dimensions()) &&
1686 verifier.VerifyVector(quantizationScales()) &&
1689 VerifyOffset(verifier, VT_DIMENSIONSPECIFICITY) &&
1690 verifier.VerifyVector(dimensionSpecificity()) &&
1691 verifier.EndTable();
1697 flatbuffers::FlatBufferBuilder &
fbb_;
1721 fbb_.AddOffset(TensorInfo::VT_DIMENSIONSPECIFICITY, dimensionSpecificity);
1725 start_ = fbb_.StartTable();
1729 const auto end = fbb_.EndTable(start_);
1730 auto o = flatbuffers::Offset<TensorInfo>(end);
1736 flatbuffers::FlatBufferBuilder &_fbb,
1739 float quantizationScale = 1.0f,
1740 int32_t quantizationOffset = 0,
1742 uint32_t quantizationDim = 0,
1743 uint32_t dimensionality = 1,
1754 return builder_.
Finish();
1758 flatbuffers::FlatBufferBuilder &_fbb,
1759 const std::vector<uint32_t> *dimensions =
nullptr,
1761 float quantizationScale = 1.0f,
1762 int32_t quantizationOffset = 0,
1763 const std::vector<float> *quantizationScales =
nullptr,
1764 uint32_t quantizationDim = 0,
1765 uint32_t dimensionality = 1,
1766 const std::vector<uint8_t> *dimensionSpecificity =
nullptr) {
1767 auto dimensions__ = dimensions ? _fbb.CreateVector<uint32_t>(*dimensions) : 0;
1768 auto quantizationScales__ = quantizationScales ? _fbb.CreateVector<
float>(*quantizationScales) : 0;
1769 auto dimensionSpecificity__ = dimensionSpecificity ? _fbb.CreateVector<uint8_t>(*dimensionSpecificity) : 0;
1776 quantizationScales__,
1779 dimensionSpecificity__);
1782 struct ByteData FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
1784 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1787 const flatbuffers::Vector<int8_t> *
data()
const {
1788 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_DATA);
1790 bool Verify(flatbuffers::Verifier &verifier)
const {
1791 return VerifyTableStart(verifier) &&
1792 VerifyOffset(verifier, VT_DATA) &&
1793 verifier.VerifyVector(data()) &&
1794 verifier.EndTable();
1800 flatbuffers::FlatBufferBuilder &
fbb_;
1803 fbb_.AddOffset(ByteData::VT_DATA, data);
1807 start_ = fbb_.StartTable();
1811 const auto end = fbb_.EndTable(start_);
1812 auto o = flatbuffers::Offset<ByteData>(end);
1818 flatbuffers::FlatBufferBuilder &_fbb,
1822 return builder_.
Finish();
1826 flatbuffers::FlatBufferBuilder &_fbb,
1827 const std::vector<int8_t> *data =
nullptr) {
1828 auto data__ = data ? _fbb.CreateVector<int8_t>(*data) : 0;
1834 struct ShortData FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
1836 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1839 const flatbuffers::Vector<int16_t> *
data()
const {
1840 return GetPointer<const flatbuffers::Vector<int16_t> *>(VT_DATA);
1842 bool Verify(flatbuffers::Verifier &verifier)
const {
1843 return VerifyTableStart(verifier) &&
1844 VerifyOffset(verifier, VT_DATA) &&
1845 verifier.VerifyVector(data()) &&
1846 verifier.EndTable();
1852 flatbuffers::FlatBufferBuilder &
fbb_;
1855 fbb_.AddOffset(ShortData::VT_DATA, data);
1859 start_ = fbb_.StartTable();
1863 const auto end = fbb_.EndTable(start_);
1864 auto o = flatbuffers::Offset<ShortData>(end);
1870 flatbuffers::FlatBufferBuilder &_fbb,
1874 return builder_.
Finish();
1878 flatbuffers::FlatBufferBuilder &_fbb,
1879 const std::vector<int16_t> *data =
nullptr) {
1880 auto data__ = data ? _fbb.CreateVector<int16_t>(*data) : 0;
1886 struct IntData FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
1888 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1891 const flatbuffers::Vector<int32_t> *
data()
const {
1892 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_DATA);
1894 bool Verify(flatbuffers::Verifier &verifier)
const {
1895 return VerifyTableStart(verifier) &&
1896 VerifyOffset(verifier, VT_DATA) &&
1897 verifier.VerifyVector(data()) &&
1898 verifier.EndTable();
1904 flatbuffers::FlatBufferBuilder &
fbb_;
1907 fbb_.AddOffset(IntData::VT_DATA, data);
1911 start_ = fbb_.StartTable();
1915 const auto end = fbb_.EndTable(start_);
1916 auto o = flatbuffers::Offset<IntData>(end);
1922 flatbuffers::FlatBufferBuilder &_fbb,
1926 return builder_.
Finish();
1930 flatbuffers::FlatBufferBuilder &_fbb,
1931 const std::vector<int32_t> *data =
nullptr) {
1932 auto data__ = data ? _fbb.CreateVector<int32_t>(*data) : 0;
1938 struct LongData FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
1940 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1943 const flatbuffers::Vector<int64_t> *
data()
const {
1944 return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_DATA);
1946 bool Verify(flatbuffers::Verifier &verifier)
const {
1947 return VerifyTableStart(verifier) &&
1948 VerifyOffset(verifier, VT_DATA) &&
1949 verifier.VerifyVector(data()) &&
1950 verifier.EndTable();
1956 flatbuffers::FlatBufferBuilder &
fbb_;
1959 fbb_.AddOffset(LongData::VT_DATA, data);
1963 start_ = fbb_.StartTable();
1967 const auto end = fbb_.EndTable(start_);
1968 auto o = flatbuffers::Offset<LongData>(end);
1974 flatbuffers::FlatBufferBuilder &_fbb,
1978 return builder_.
Finish();
1982 flatbuffers::FlatBufferBuilder &_fbb,
1983 const std::vector<int64_t> *data =
nullptr) {
1984 auto data__ = data ? _fbb.CreateVector<int64_t>(*data) : 0;
1990 struct ConstTensor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
1992 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1997 const armnnSerializer::TensorInfo *
info()
const {
1998 return GetPointer<const armnnSerializer::TensorInfo *>(
VT_INFO);
2004 return GetPointer<const void *>(VT_DATA);
2006 template<
typename T>
const T *data_as()
const;
2019 bool Verify(flatbuffers::Verifier &verifier)
const {
2020 return VerifyTableStart(verifier) &&
2021 VerifyOffset(verifier,
VT_INFO) &&
2022 verifier.VerifyTable(info()) &&
2024 VerifyOffset(verifier, VT_DATA) &&
2026 verifier.EndTable();
2030 template<>
inline const armnnSerializer::ByteData *ConstTensor::data_as<armnnSerializer::ByteData>()
const {
2031 return data_as_ByteData();
2034 template<>
inline const armnnSerializer::ShortData *ConstTensor::data_as<armnnSerializer::ShortData>()
const {
2035 return data_as_ShortData();
2038 template<>
inline const armnnSerializer::IntData *ConstTensor::data_as<armnnSerializer::IntData>()
const {
2039 return data_as_IntData();
2042 template<>
inline const armnnSerializer::LongData *ConstTensor::data_as<armnnSerializer::LongData>()
const {
2043 return data_as_LongData();
2048 flatbuffers::FlatBufferBuilder &
fbb_;
2050 void add_info(flatbuffers::Offset<armnnSerializer::TensorInfo> info) {
2057 fbb_.AddOffset(ConstTensor::VT_DATA, data);
2061 start_ = fbb_.StartTable();
2065 const auto end = fbb_.EndTable(start_);
2066 auto o = flatbuffers::Offset<ConstTensor>(end);
2072 flatbuffers::FlatBufferBuilder &_fbb,
2073 flatbuffers::Offset<armnnSerializer::TensorInfo> info = 0,
2075 flatbuffers::Offset<void> data = 0) {
2080 return builder_.
Finish();
2083 struct InputSlot FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2085 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2090 return GetField<uint32_t>(
VT_INDEX, 0);
2093 return GetStruct<const armnnSerializer::Connection *>(VT_CONNECTION);
2095 bool Verify(flatbuffers::Verifier &verifier)
const {
2096 return VerifyTableStart(verifier) &&
2097 VerifyField<uint32_t>(verifier,
VT_INDEX) &&
2098 VerifyField<armnnSerializer::Connection>(verifier, VT_CONNECTION) &&
2099 verifier.EndTable();
2105 flatbuffers::FlatBufferBuilder &
fbb_;
2111 fbb_.AddStruct(InputSlot::VT_CONNECTION, connection);
2115 start_ = fbb_.StartTable();
2119 const auto end = fbb_.EndTable(start_);
2120 auto o = flatbuffers::Offset<InputSlot>(end);
2126 flatbuffers::FlatBufferBuilder &_fbb,
2128 const armnnSerializer::Connection *connection = 0) {
2132 return builder_.
Finish();
2135 struct OutputSlot FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2137 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2142 return GetField<uint32_t>(
VT_INDEX, 0);
2145 return GetPointer<const armnnSerializer::TensorInfo *>(VT_TENSORINFO);
2147 bool Verify(flatbuffers::Verifier &verifier)
const {
2148 return VerifyTableStart(verifier) &&
2149 VerifyField<uint32_t>(verifier,
VT_INDEX) &&
2150 VerifyOffset(verifier, VT_TENSORINFO) &&
2151 verifier.VerifyTable(tensorInfo()) &&
2152 verifier.EndTable();
2158 flatbuffers::FlatBufferBuilder &
fbb_;
2164 fbb_.AddOffset(OutputSlot::VT_TENSORINFO, tensorInfo);
2168 start_ = fbb_.StartTable();
2172 const auto end = fbb_.EndTable(start_);
2173 auto o = flatbuffers::Offset<OutputSlot>(end);
2179 flatbuffers::FlatBufferBuilder &_fbb,
2181 flatbuffers::Offset<armnnSerializer::TensorInfo> tensorInfo = 0) {
2185 return builder_.
Finish();
2188 struct LayerBase FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2190 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2198 return GetField<uint32_t>(
VT_INDEX, 0);
2201 return GetPointer<const flatbuffers::String *>(
VT_LAYERNAME);
2206 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::InputSlot>> *
inputSlots()
const {
2207 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::InputSlot>> *>(
VT_INPUTSLOTS);
2209 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::OutputSlot>> *
outputSlots()
const {
2210 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::OutputSlot>> *>(VT_OUTPUTSLOTS);
2212 bool Verify(flatbuffers::Verifier &verifier)
const {
2213 return VerifyTableStart(verifier) &&
2214 VerifyField<uint32_t>(verifier,
VT_INDEX) &&
2216 verifier.VerifyString(layerName()) &&
2219 verifier.VerifyVector(inputSlots()) &&
2220 verifier.VerifyVectorOfTables(inputSlots()) &&
2221 VerifyOffset(verifier, VT_OUTPUTSLOTS) &&
2222 verifier.VerifyVector(outputSlots()) &&
2223 verifier.VerifyVectorOfTables(outputSlots()) &&
2224 verifier.EndTable();
2230 flatbuffers::FlatBufferBuilder &
fbb_;
2245 fbb_.AddOffset(LayerBase::VT_OUTPUTSLOTS, outputSlots);
2249 start_ = fbb_.StartTable();
2253 const auto end = fbb_.EndTable(start_);
2254 auto o = flatbuffers::Offset<LayerBase>(end);
2260 flatbuffers::FlatBufferBuilder &_fbb,
2262 flatbuffers::Offset<flatbuffers::String> layerName = 0,
2264 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::InputSlot>>> inputSlots = 0,
2265 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::OutputSlot>>> outputSlots = 0) {
2272 return builder_.
Finish();
2276 flatbuffers::FlatBufferBuilder &_fbb,
2278 const char *layerName =
nullptr,
2280 const std::vector<flatbuffers::Offset<armnnSerializer::InputSlot>> *inputSlots =
nullptr,
2281 const std::vector<flatbuffers::Offset<armnnSerializer::OutputSlot>> *outputSlots =
nullptr) {
2282 auto layerName__ = layerName ? _fbb.CreateString(layerName) : 0;
2283 auto inputSlots__ = inputSlots ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::InputSlot>>(*inputSlots) : 0;
2284 auto outputSlots__ = outputSlots ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::OutputSlot>>(*outputSlots) : 0;
2294 struct BindableLayerBase FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2296 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2298 VT_LAYERBINDINGID = 6
2300 const armnnSerializer::LayerBase *
base()
const {
2301 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2304 return GetField<int32_t>(VT_LAYERBINDINGID, 0);
2306 bool Verify(flatbuffers::Verifier &verifier)
const {
2307 return VerifyTableStart(verifier) &&
2308 VerifyOffset(verifier,
VT_BASE) &&
2309 verifier.VerifyTable(base()) &&
2310 VerifyField<int32_t>(verifier, VT_LAYERBINDINGID) &&
2311 verifier.EndTable();
2317 flatbuffers::FlatBufferBuilder &
fbb_;
2319 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2323 fbb_.AddElement<int32_t>(BindableLayerBase::VT_LAYERBINDINGID, layerBindingId, 0);
2327 start_ = fbb_.StartTable();
2330 flatbuffers::Offset<BindableLayerBase>
Finish() {
2331 const auto end = fbb_.EndTable(start_);
2332 auto o = flatbuffers::Offset<BindableLayerBase>(end);
2338 flatbuffers::FlatBufferBuilder &_fbb,
2339 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2340 int32_t layerBindingId = 0) {
2344 return builder_.
Finish();
2348 struct AbsLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2350 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2353 const armnnSerializer::LayerBase *
base()
const {
2354 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2356 bool Verify(flatbuffers::Verifier &verifier)
const {
2357 return VerifyTableStart(verifier) &&
2358 VerifyOffset(verifier,
VT_BASE) &&
2359 verifier.VerifyTable(base()) &&
2360 verifier.EndTable();
2366 flatbuffers::FlatBufferBuilder &
fbb_;
2368 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2373 start_ = fbb_.StartTable();
2377 const auto end = fbb_.EndTable(start_);
2378 auto o = flatbuffers::Offset<AbsLayer>(end);
2384 flatbuffers::FlatBufferBuilder &_fbb,
2385 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
2388 return builder_.
Finish();
2391 struct ActivationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2393 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2397 const armnnSerializer::LayerBase *
base()
const {
2398 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2400 const armnnSerializer::ActivationDescriptor *
descriptor()
const {
2401 return GetPointer<const armnnSerializer::ActivationDescriptor *>(
VT_DESCRIPTOR);
2403 bool Verify(flatbuffers::Verifier &verifier)
const {
2404 return VerifyTableStart(verifier) &&
2405 VerifyOffset(verifier,
VT_BASE) &&
2406 verifier.VerifyTable(base()) &&
2408 verifier.VerifyTable(descriptor()) &&
2409 verifier.EndTable();
2415 flatbuffers::FlatBufferBuilder &
fbb_;
2417 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2420 void add_descriptor(flatbuffers::Offset<armnnSerializer::ActivationDescriptor> descriptor) {
2425 start_ = fbb_.StartTable();
2428 flatbuffers::Offset<ActivationLayer>
Finish() {
2429 const auto end = fbb_.EndTable(start_);
2430 auto o = flatbuffers::Offset<ActivationLayer>(end);
2436 flatbuffers::FlatBufferBuilder &_fbb,
2437 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2438 flatbuffers::Offset<armnnSerializer::ActivationDescriptor> descriptor = 0) {
2442 return builder_.
Finish();
2445 struct ActivationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2447 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2456 return GetField<float>(
VT_A, 0.0f);
2459 return GetField<float>(VT_B, 0.0f);
2461 bool Verify(flatbuffers::Verifier &verifier)
const {
2462 return VerifyTableStart(verifier) &&
2464 VerifyField<float>(verifier,
VT_A) &&
2465 VerifyField<float>(verifier, VT_B) &&
2466 verifier.EndTable();
2472 flatbuffers::FlatBufferBuilder &
fbb_;
2481 fbb_.AddElement<
float>(ActivationDescriptor::VT_B, b, 0.0f);
2485 start_ = fbb_.StartTable();
2488 flatbuffers::Offset<ActivationDescriptor>
Finish() {
2489 const auto end = fbb_.EndTable(start_);
2490 auto o = flatbuffers::Offset<ActivationDescriptor>(end);
2496 flatbuffers::FlatBufferBuilder &_fbb,
2504 return builder_.
Finish();
2507 struct AdditionLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2509 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2512 const armnnSerializer::LayerBase *
base()
const {
2513 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2515 bool Verify(flatbuffers::Verifier &verifier)
const {
2516 return VerifyTableStart(verifier) &&
2517 VerifyOffset(verifier,
VT_BASE) &&
2518 verifier.VerifyTable(base()) &&
2519 verifier.EndTable();
2525 flatbuffers::FlatBufferBuilder &
fbb_;
2527 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2532 start_ = fbb_.StartTable();
2535 flatbuffers::Offset<AdditionLayer>
Finish() {
2536 const auto end = fbb_.EndTable(start_);
2537 auto o = flatbuffers::Offset<AdditionLayer>(end);
2543 flatbuffers::FlatBufferBuilder &_fbb,
2544 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
2547 return builder_.
Finish();
2550 struct ArgMinMaxLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2552 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2556 const armnnSerializer::LayerBase *
base()
const {
2557 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2560 return GetPointer<const armnnSerializer::ArgMinMaxDescriptor *>(
VT_DESCRIPTOR);
2562 bool Verify(flatbuffers::Verifier &verifier)
const {
2563 return VerifyTableStart(verifier) &&
2564 VerifyOffset(verifier,
VT_BASE) &&
2565 verifier.VerifyTable(base()) &&
2567 verifier.VerifyTable(descriptor()) &&
2568 verifier.EndTable();
2574 flatbuffers::FlatBufferBuilder &
fbb_;
2576 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2579 void add_descriptor(flatbuffers::Offset<armnnSerializer::ArgMinMaxDescriptor> descriptor) {
2584 start_ = fbb_.StartTable();
2587 flatbuffers::Offset<ArgMinMaxLayer>
Finish() {
2588 const auto end = fbb_.EndTable(start_);
2589 auto o = flatbuffers::Offset<ArgMinMaxLayer>(end);
2595 flatbuffers::FlatBufferBuilder &_fbb,
2596 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2597 flatbuffers::Offset<armnnSerializer::ArgMinMaxDescriptor> descriptor = 0) {
2601 return builder_.
Finish();
2604 struct ArgMinMaxDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2606 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2614 return GetField<int32_t>(
VT_AXIS, 0);
2616 bool Verify(flatbuffers::Verifier &verifier)
const {
2617 return VerifyTableStart(verifier) &&
2619 VerifyField<int32_t>(verifier,
VT_AXIS) &&
2620 verifier.EndTable();
2626 flatbuffers::FlatBufferBuilder &
fbb_;
2636 start_ = fbb_.StartTable();
2639 flatbuffers::Offset<ArgMinMaxDescriptor>
Finish() {
2640 const auto end = fbb_.EndTable(start_);
2641 auto o = flatbuffers::Offset<ArgMinMaxDescriptor>(end);
2647 flatbuffers::FlatBufferBuilder &_fbb,
2653 return builder_.
Finish();
2656 struct CastLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2658 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2661 const armnnSerializer::LayerBase *
base()
const {
2662 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2664 bool Verify(flatbuffers::Verifier &verifier)
const {
2665 return VerifyTableStart(verifier) &&
2666 VerifyOffset(verifier,
VT_BASE) &&
2667 verifier.VerifyTable(base()) &&
2668 verifier.EndTable();
2674 flatbuffers::FlatBufferBuilder &
fbb_;
2676 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2681 start_ = fbb_.StartTable();
2685 const auto end = fbb_.EndTable(start_);
2686 auto o = flatbuffers::Offset<CastLayer>(end);
2692 flatbuffers::FlatBufferBuilder &_fbb,
2693 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
2696 return builder_.
Finish();
2699 struct ComparisonDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2701 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2707 bool Verify(flatbuffers::Verifier &verifier)
const {
2708 return VerifyTableStart(verifier) &&
2709 VerifyField<int8_t>(verifier, VT_OPERATION) &&
2710 verifier.EndTable();
2716 flatbuffers::FlatBufferBuilder &
fbb_;
2719 fbb_.AddElement<int8_t>(ComparisonDescriptor::VT_OPERATION,
static_cast<int8_t
>(operation), 0);
2723 start_ = fbb_.StartTable();
2726 flatbuffers::Offset<ComparisonDescriptor>
Finish() {
2727 const auto end = fbb_.EndTable(start_);
2728 auto o = flatbuffers::Offset<ComparisonDescriptor>(end);
2734 flatbuffers::FlatBufferBuilder &_fbb,
2738 return builder_.
Finish();
2741 struct ComparisonLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2743 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2747 const armnnSerializer::LayerBase *
base()
const {
2748 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2750 const armnnSerializer::ComparisonDescriptor *
descriptor()
const {
2751 return GetPointer<const armnnSerializer::ComparisonDescriptor *>(
VT_DESCRIPTOR);
2753 bool Verify(flatbuffers::Verifier &verifier)
const {
2754 return VerifyTableStart(verifier) &&
2755 VerifyOffset(verifier,
VT_BASE) &&
2756 verifier.VerifyTable(base()) &&
2758 verifier.VerifyTable(descriptor()) &&
2759 verifier.EndTable();
2765 flatbuffers::FlatBufferBuilder &
fbb_;
2767 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2770 void add_descriptor(flatbuffers::Offset<armnnSerializer::ComparisonDescriptor> descriptor) {
2775 start_ = fbb_.StartTable();
2778 flatbuffers::Offset<ComparisonLayer>
Finish() {
2779 const auto end = fbb_.EndTable(start_);
2780 auto o = flatbuffers::Offset<ComparisonLayer>(end);
2786 flatbuffers::FlatBufferBuilder &_fbb,
2787 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2788 flatbuffers::Offset<armnnSerializer::ComparisonDescriptor> descriptor = 0) {
2792 return builder_.
Finish();
2795 struct ConstantLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2797 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2801 const armnnSerializer::LayerBase *
base()
const {
2802 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2804 const armnnSerializer::ConstTensor *
input()
const {
2805 return GetPointer<const armnnSerializer::ConstTensor *>(VT_INPUT);
2807 bool Verify(flatbuffers::Verifier &verifier)
const {
2808 return VerifyTableStart(verifier) &&
2809 VerifyOffset(verifier,
VT_BASE) &&
2810 verifier.VerifyTable(base()) &&
2811 VerifyOffset(verifier, VT_INPUT) &&
2812 verifier.VerifyTable(input()) &&
2813 verifier.EndTable();
2819 flatbuffers::FlatBufferBuilder &
fbb_;
2821 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2824 void add_input(flatbuffers::Offset<armnnSerializer::ConstTensor> input) {
2825 fbb_.AddOffset(ConstantLayer::VT_INPUT, input);
2829 start_ = fbb_.StartTable();
2832 flatbuffers::Offset<ConstantLayer>
Finish() {
2833 const auto end = fbb_.EndTable(start_);
2834 auto o = flatbuffers::Offset<ConstantLayer>(end);
2840 flatbuffers::FlatBufferBuilder &_fbb,
2841 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2842 flatbuffers::Offset<armnnSerializer::ConstTensor> input = 0) {
2846 return builder_.
Finish();
2849 struct Convolution2dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2851 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2857 const armnnSerializer::LayerBase *
base()
const {
2858 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2860 const armnnSerializer::Convolution2dDescriptor *
descriptor()
const {
2861 return GetPointer<const armnnSerializer::Convolution2dDescriptor *>(
VT_DESCRIPTOR);
2863 const armnnSerializer::ConstTensor *
weights()
const {
2864 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_WEIGHTS);
2866 const armnnSerializer::ConstTensor *
biases()
const {
2867 return GetPointer<const armnnSerializer::ConstTensor *>(VT_BIASES);
2869 bool Verify(flatbuffers::Verifier &verifier)
const {
2870 return VerifyTableStart(verifier) &&
2871 VerifyOffset(verifier,
VT_BASE) &&
2872 verifier.VerifyTable(base()) &&
2874 verifier.VerifyTable(descriptor()) &&
2876 verifier.VerifyTable(weights()) &&
2877 VerifyOffset(verifier, VT_BIASES) &&
2878 verifier.VerifyTable(biases()) &&
2879 verifier.EndTable();
2885 flatbuffers::FlatBufferBuilder &
fbb_;
2887 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2890 void add_descriptor(flatbuffers::Offset<armnnSerializer::Convolution2dDescriptor> descriptor) {
2893 void add_weights(flatbuffers::Offset<armnnSerializer::ConstTensor> weights) {
2896 void add_biases(flatbuffers::Offset<armnnSerializer::ConstTensor> biases) {
2897 fbb_.AddOffset(Convolution2dLayer::VT_BIASES, biases);
2901 start_ = fbb_.StartTable();
2904 flatbuffers::Offset<Convolution2dLayer>
Finish() {
2905 const auto end = fbb_.EndTable(start_);
2906 auto o = flatbuffers::Offset<Convolution2dLayer>(end);
2912 flatbuffers::FlatBufferBuilder &_fbb,
2913 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2914 flatbuffers::Offset<armnnSerializer::Convolution2dDescriptor> descriptor = 0,
2915 flatbuffers::Offset<armnnSerializer::ConstTensor> weights = 0,
2916 flatbuffers::Offset<armnnSerializer::ConstTensor> biases = 0) {
2922 return builder_.
Finish();
2925 struct Convolution2dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2927 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2946 return GetField<uint32_t>(
VT_PADTOP, 0);
2969 bool Verify(flatbuffers::Verifier &verifier)
const {
2970 return VerifyTableStart(verifier) &&
2971 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
2973 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
2975 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
2976 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
2981 verifier.EndTable();
2987 flatbuffers::FlatBufferBuilder &
fbb_;
3021 start_ = fbb_.StartTable();
3024 flatbuffers::Offset<Convolution2dDescriptor>
Finish() {
3025 const auto end = fbb_.EndTable(start_);
3026 auto o = flatbuffers::Offset<Convolution2dDescriptor>(end);
3032 flatbuffers::FlatBufferBuilder &_fbb,
3033 uint32_t padLeft = 0,
3034 uint32_t padRight = 0,
3035 uint32_t padTop = 0,
3036 uint32_t padBottom = 0,
3037 uint32_t strideX = 0,
3038 uint32_t strideY = 0,
3039 uint32_t dilationX = 1,
3040 uint32_t dilationY = 1,
3041 bool biasEnabled =
false,
3054 return builder_.
Finish();
3057 struct DepthToSpaceLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3059 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3063 const armnnSerializer::LayerBase *
base()
const {
3064 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3067 return GetPointer<const armnnSerializer::DepthToSpaceDescriptor *>(
VT_DESCRIPTOR);
3069 bool Verify(flatbuffers::Verifier &verifier)
const {
3070 return VerifyTableStart(verifier) &&
3071 VerifyOffset(verifier,
VT_BASE) &&
3072 verifier.VerifyTable(base()) &&
3074 verifier.VerifyTable(descriptor()) &&
3075 verifier.EndTable();
3081 flatbuffers::FlatBufferBuilder &
fbb_;
3083 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3086 void add_descriptor(flatbuffers::Offset<armnnSerializer::DepthToSpaceDescriptor> descriptor) {
3091 start_ = fbb_.StartTable();
3094 flatbuffers::Offset<DepthToSpaceLayer>
Finish() {
3095 const auto end = fbb_.EndTable(start_);
3096 auto o = flatbuffers::Offset<DepthToSpaceLayer>(end);
3102 flatbuffers::FlatBufferBuilder &_fbb,
3103 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3104 flatbuffers::Offset<armnnSerializer::DepthToSpaceDescriptor> descriptor = 0) {
3108 return builder_.
Finish();
3113 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3123 bool Verify(flatbuffers::Verifier &verifier)
const {
3124 return VerifyTableStart(verifier) &&
3127 verifier.EndTable();
3133 flatbuffers::FlatBufferBuilder &
fbb_;
3143 start_ = fbb_.StartTable();
3146 flatbuffers::Offset<DepthToSpaceDescriptor>
Finish() {
3147 const auto end = fbb_.EndTable(start_);
3148 auto o = flatbuffers::Offset<DepthToSpaceDescriptor>(end);
3154 flatbuffers::FlatBufferBuilder &_fbb,
3155 uint32_t blockSize = 0,
3160 return builder_.
Finish();
3163 struct DivisionLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3165 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3168 const armnnSerializer::LayerBase *
base()
const {
3169 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3171 bool Verify(flatbuffers::Verifier &verifier)
const {
3172 return VerifyTableStart(verifier) &&
3173 VerifyOffset(verifier,
VT_BASE) &&
3174 verifier.VerifyTable(base()) &&
3175 verifier.EndTable();
3181 flatbuffers::FlatBufferBuilder &
fbb_;
3183 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3188 start_ = fbb_.StartTable();
3191 flatbuffers::Offset<DivisionLayer>
Finish() {
3192 const auto end = fbb_.EndTable(start_);
3193 auto o = flatbuffers::Offset<DivisionLayer>(end);
3199 flatbuffers::FlatBufferBuilder &_fbb,
3200 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
3203 return builder_.
Finish();
3206 struct ElementwiseUnaryDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3208 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3214 bool Verify(flatbuffers::Verifier &verifier)
const {
3215 return VerifyTableStart(verifier) &&
3216 VerifyField<int8_t>(verifier, VT_OPERATION) &&
3217 verifier.EndTable();
3222 typedef ElementwiseUnaryDescriptor
Table;
3223 flatbuffers::FlatBufferBuilder &
fbb_;
3226 fbb_.AddElement<int8_t>(ElementwiseUnaryDescriptor::VT_OPERATION,
static_cast<int8_t
>(operation), 0);
3230 start_ = fbb_.StartTable();
3233 flatbuffers::Offset<ElementwiseUnaryDescriptor>
Finish() {
3234 const auto end = fbb_.EndTable(start_);
3235 auto o = flatbuffers::Offset<ElementwiseUnaryDescriptor>(end);
3241 flatbuffers::FlatBufferBuilder &_fbb,
3245 return builder_.
Finish();
3248 struct ElementwiseUnaryLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3250 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3254 const armnnSerializer::LayerBase *
base()
const {
3255 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3257 const armnnSerializer::ElementwiseUnaryDescriptor *
descriptor()
const {
3258 return GetPointer<const armnnSerializer::ElementwiseUnaryDescriptor *>(
VT_DESCRIPTOR);
3260 bool Verify(flatbuffers::Verifier &verifier)
const {
3261 return VerifyTableStart(verifier) &&
3262 VerifyOffset(verifier,
VT_BASE) &&
3263 verifier.VerifyTable(base()) &&
3265 verifier.VerifyTable(descriptor()) &&
3266 verifier.EndTable();
3272 flatbuffers::FlatBufferBuilder &
fbb_;
3274 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3277 void add_descriptor(flatbuffers::Offset<armnnSerializer::ElementwiseUnaryDescriptor> descriptor) {
3282 start_ = fbb_.StartTable();
3285 flatbuffers::Offset<ElementwiseUnaryLayer>
Finish() {
3286 const auto end = fbb_.EndTable(start_);
3287 auto o = flatbuffers::Offset<ElementwiseUnaryLayer>(end);
3293 flatbuffers::FlatBufferBuilder &_fbb,
3294 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3295 flatbuffers::Offset<armnnSerializer::ElementwiseUnaryDescriptor> descriptor = 0) {
3299 return builder_.
Finish();
3303 struct EqualLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3305 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3308 const armnnSerializer::LayerBase *
base()
const {
3309 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3311 bool Verify(flatbuffers::Verifier &verifier)
const {
3312 return VerifyTableStart(verifier) &&
3313 VerifyOffset(verifier,
VT_BASE) &&
3314 verifier.VerifyTable(base()) &&
3315 verifier.EndTable();
3321 flatbuffers::FlatBufferBuilder &
fbb_;
3323 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3328 start_ = fbb_.StartTable();
3332 const auto end = fbb_.EndTable(start_);
3333 auto o = flatbuffers::Offset<EqualLayer>(end);
3339 flatbuffers::FlatBufferBuilder &_fbb,
3340 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
3343 return builder_.
Finish();
3346 struct FillLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3348 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3352 const armnnSerializer::LayerBase *
base()
const {
3353 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3356 return GetPointer<const armnnSerializer::FillDescriptor *>(
VT_DESCRIPTOR);
3358 bool Verify(flatbuffers::Verifier &verifier)
const {
3359 return VerifyTableStart(verifier) &&
3360 VerifyOffset(verifier,
VT_BASE) &&
3361 verifier.VerifyTable(base()) &&
3363 verifier.VerifyTable(descriptor()) &&
3364 verifier.EndTable();
3370 flatbuffers::FlatBufferBuilder &
fbb_;
3372 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3375 void add_descriptor(flatbuffers::Offset<armnnSerializer::FillDescriptor> descriptor) {
3380 start_ = fbb_.StartTable();
3384 const auto end = fbb_.EndTable(start_);
3385 auto o = flatbuffers::Offset<FillLayer>(end);
3391 flatbuffers::FlatBufferBuilder &_fbb,
3392 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3393 flatbuffers::Offset<armnnSerializer::FillDescriptor> descriptor = 0) {
3397 return builder_.
Finish();
3400 struct FillDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3402 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3406 return GetField<float>(VT_VALUE, 0.0f);
3408 bool Verify(flatbuffers::Verifier &verifier)
const {
3409 return VerifyTableStart(verifier) &&
3410 VerifyField<float>(verifier, VT_VALUE) &&
3411 verifier.EndTable();
3417 flatbuffers::FlatBufferBuilder &
fbb_;
3420 fbb_.AddElement<
float>(FillDescriptor::VT_VALUE, value, 0.0f);
3424 start_ = fbb_.StartTable();
3427 flatbuffers::Offset<FillDescriptor>
Finish() {
3428 const auto end = fbb_.EndTable(start_);
3429 auto o = flatbuffers::Offset<FillDescriptor>(end);
3435 flatbuffers::FlatBufferBuilder &_fbb,
3436 float value = 0.0f) {
3439 return builder_.
Finish();
3442 struct FloorLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3444 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3447 const armnnSerializer::LayerBase *
base()
const {
3448 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3450 bool Verify(flatbuffers::Verifier &verifier)
const {
3451 return VerifyTableStart(verifier) &&
3452 VerifyOffset(verifier,
VT_BASE) &&
3453 verifier.VerifyTable(base()) &&
3454 verifier.EndTable();
3460 flatbuffers::FlatBufferBuilder &
fbb_;
3462 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3467 start_ = fbb_.StartTable();
3471 const auto end = fbb_.EndTable(start_);
3472 auto o = flatbuffers::Offset<FloorLayer>(end);
3478 flatbuffers::FlatBufferBuilder &_fbb,
3479 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
3482 return builder_.
Finish();
3485 struct FullyConnectedLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3487 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3493 const armnnSerializer::LayerBase *
base()
const {
3494 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3496 const armnnSerializer::FullyConnectedDescriptor *
descriptor()
const {
3497 return GetPointer<const armnnSerializer::FullyConnectedDescriptor *>(
VT_DESCRIPTOR);
3499 const armnnSerializer::ConstTensor *
weights()
const {
3500 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_WEIGHTS);
3502 const armnnSerializer::ConstTensor *
biases()
const {
3503 return GetPointer<const armnnSerializer::ConstTensor *>(VT_BIASES);
3505 bool Verify(flatbuffers::Verifier &verifier)
const {
3506 return VerifyTableStart(verifier) &&
3507 VerifyOffset(verifier,
VT_BASE) &&
3508 verifier.VerifyTable(base()) &&
3510 verifier.VerifyTable(descriptor()) &&
3512 verifier.VerifyTable(weights()) &&
3513 VerifyOffset(verifier, VT_BIASES) &&
3514 verifier.VerifyTable(biases()) &&
3515 verifier.EndTable();
3521 flatbuffers::FlatBufferBuilder &
fbb_;
3523 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3526 void add_descriptor(flatbuffers::Offset<armnnSerializer::FullyConnectedDescriptor> descriptor) {
3529 void add_weights(flatbuffers::Offset<armnnSerializer::ConstTensor> weights) {
3532 void add_biases(flatbuffers::Offset<armnnSerializer::ConstTensor> biases) {
3533 fbb_.AddOffset(FullyConnectedLayer::VT_BIASES, biases);
3537 start_ = fbb_.StartTable();
3540 flatbuffers::Offset<FullyConnectedLayer>
Finish() {
3541 const auto end = fbb_.EndTable(start_);
3542 auto o = flatbuffers::Offset<FullyConnectedLayer>(end);
3548 flatbuffers::FlatBufferBuilder &_fbb,
3549 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3550 flatbuffers::Offset<armnnSerializer::FullyConnectedDescriptor> descriptor = 0,
3551 flatbuffers::Offset<armnnSerializer::ConstTensor> weights = 0,
3552 flatbuffers::Offset<armnnSerializer::ConstTensor> biases = 0) {
3558 return builder_.
Finish();
3561 struct FullyConnectedDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3563 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3566 VT_CONSTANTWEIGHTS = 8
3575 return GetField<uint8_t>(VT_CONSTANTWEIGHTS, 1) != 0;
3577 bool Verify(flatbuffers::Verifier &verifier)
const {
3578 return VerifyTableStart(verifier) &&
3581 VerifyField<uint8_t>(verifier, VT_CONSTANTWEIGHTS) &&
3582 verifier.EndTable();
3588 flatbuffers::FlatBufferBuilder &
fbb_;
3597 fbb_.AddElement<uint8_t>(FullyConnectedDescriptor::VT_CONSTANTWEIGHTS,
static_cast<uint8_t
>(constantWeights), 1);
3601 start_ = fbb_.StartTable();
3604 flatbuffers::Offset<FullyConnectedDescriptor>
Finish() {
3605 const auto end = fbb_.EndTable(start_);
3606 auto o = flatbuffers::Offset<FullyConnectedDescriptor>(end);
3612 flatbuffers::FlatBufferBuilder &_fbb,
3613 bool biasEnabled =
false,
3614 bool transposeWeightsMatrix =
false,
3615 bool constantWeights =
true) {
3620 return builder_.
Finish();
3623 struct GatherLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3625 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3629 const armnnSerializer::LayerBase *
base()
const {
3630 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3633 return GetPointer<const armnnSerializer::GatherDescriptor *>(
VT_DESCRIPTOR);
3635 bool Verify(flatbuffers::Verifier &verifier)
const {
3636 return VerifyTableStart(verifier) &&
3637 VerifyOffset(verifier,
VT_BASE) &&
3638 verifier.VerifyTable(base()) &&
3640 verifier.VerifyTable(descriptor()) &&
3641 verifier.EndTable();
3647 flatbuffers::FlatBufferBuilder &
fbb_;
3649 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3652 void add_descriptor(flatbuffers::Offset<armnnSerializer::GatherDescriptor> descriptor) {
3657 start_ = fbb_.StartTable();
3661 const auto end = fbb_.EndTable(start_);
3662 auto o = flatbuffers::Offset<GatherLayer>(end);
3668 flatbuffers::FlatBufferBuilder &_fbb,
3669 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3670 flatbuffers::Offset<armnnSerializer::GatherDescriptor> descriptor = 0) {
3674 return builder_.
Finish();
3677 struct GatherDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3679 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3683 return GetField<int32_t>(
VT_AXIS, 0);
3685 bool Verify(flatbuffers::Verifier &verifier)
const {
3686 return VerifyTableStart(verifier) &&
3687 VerifyField<int32_t>(verifier,
VT_AXIS) &&
3688 verifier.EndTable();
3694 flatbuffers::FlatBufferBuilder &
fbb_;
3701 start_ = fbb_.StartTable();
3704 flatbuffers::Offset<GatherDescriptor>
Finish() {
3705 const auto end = fbb_.EndTable(start_);
3706 auto o = flatbuffers::Offset<GatherDescriptor>(end);
3712 flatbuffers::FlatBufferBuilder &_fbb,
3716 return builder_.
Finish();
3720 struct GreaterLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3722 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3725 const armnnSerializer::LayerBase *
base()
const {
3726 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3728 bool Verify(flatbuffers::Verifier &verifier)
const {
3729 return VerifyTableStart(verifier) &&
3730 VerifyOffset(verifier,
VT_BASE) &&
3731 verifier.VerifyTable(base()) &&
3732 verifier.EndTable();
3738 flatbuffers::FlatBufferBuilder &
fbb_;
3740 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3745 start_ = fbb_.StartTable();
3749 const auto end = fbb_.EndTable(start_);
3750 auto o = flatbuffers::Offset<GreaterLayer>(end);
3756 flatbuffers::FlatBufferBuilder &_fbb,
3757 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
3760 return builder_.
Finish();
3763 struct InputLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3765 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3768 const armnnSerializer::BindableLayerBase *
base()
const {
3769 return GetPointer<const armnnSerializer::BindableLayerBase *>(
VT_BASE);
3771 bool Verify(flatbuffers::Verifier &verifier)
const {
3772 return VerifyTableStart(verifier) &&
3773 VerifyOffset(verifier,
VT_BASE) &&
3774 verifier.VerifyTable(base()) &&
3775 verifier.EndTable();
3781 flatbuffers::FlatBufferBuilder &
fbb_;
3783 void add_base(flatbuffers::Offset<armnnSerializer::BindableLayerBase> base) {
3788 start_ = fbb_.StartTable();
3792 const auto end = fbb_.EndTable(start_);
3793 auto o = flatbuffers::Offset<InputLayer>(end);
3799 flatbuffers::FlatBufferBuilder &_fbb,
3800 flatbuffers::Offset<armnnSerializer::BindableLayerBase> base = 0) {
3803 return builder_.
Finish();
3806 struct InstanceNormalizationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3808 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3812 const armnnSerializer::LayerBase *
base()
const {
3813 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3815 const armnnSerializer::InstanceNormalizationDescriptor *
descriptor()
const {
3816 return GetPointer<const armnnSerializer::InstanceNormalizationDescriptor *>(
VT_DESCRIPTOR);
3818 bool Verify(flatbuffers::Verifier &verifier)
const {
3819 return VerifyTableStart(verifier) &&
3820 VerifyOffset(verifier,
VT_BASE) &&
3821 verifier.VerifyTable(base()) &&
3823 verifier.VerifyTable(descriptor()) &&
3824 verifier.EndTable();
3829 typedef InstanceNormalizationLayer
Table;
3830 flatbuffers::FlatBufferBuilder &
fbb_;
3832 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3835 void add_descriptor(flatbuffers::Offset<armnnSerializer::InstanceNormalizationDescriptor> descriptor) {
3840 start_ = fbb_.StartTable();
3843 flatbuffers::Offset<InstanceNormalizationLayer>
Finish() {
3844 const auto end = fbb_.EndTable(start_);
3845 auto o = flatbuffers::Offset<InstanceNormalizationLayer>(end);
3851 flatbuffers::FlatBufferBuilder &_fbb,
3852 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3853 flatbuffers::Offset<armnnSerializer::InstanceNormalizationDescriptor> descriptor = 0) {
3857 return builder_.
Finish();
3860 struct InstanceNormalizationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3862 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3869 return GetField<float>(
VT_GAMMA, 0.0f);
3872 return GetField<float>(
VT_BETA, 0.0f);
3875 return GetField<float>(
VT_EPS, 0.0f);
3880 bool Verify(flatbuffers::Verifier &verifier)
const {
3881 return VerifyTableStart(verifier) &&
3882 VerifyField<float>(verifier,
VT_GAMMA) &&
3883 VerifyField<float>(verifier,
VT_BETA) &&
3884 VerifyField<float>(verifier,
VT_EPS) &&
3886 verifier.EndTable();
3891 typedef InstanceNormalizationDescriptor
Table;
3892 flatbuffers::FlatBufferBuilder &
fbb_;
3908 start_ = fbb_.StartTable();
3911 flatbuffers::Offset<InstanceNormalizationDescriptor>
Finish() {
3912 const auto end = fbb_.EndTable(start_);
3913 auto o = flatbuffers::Offset<InstanceNormalizationDescriptor>(end);
3919 flatbuffers::FlatBufferBuilder &_fbb,
3929 return builder_.
Finish();
3932 struct LogSoftmaxLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3934 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3938 const armnnSerializer::LayerBase *
base()
const {
3939 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3942 return GetPointer<const armnnSerializer::LogSoftmaxDescriptor *>(
VT_DESCRIPTOR);
3944 bool Verify(flatbuffers::Verifier &verifier)
const {
3945 return VerifyTableStart(verifier) &&
3946 VerifyOffset(verifier,
VT_BASE) &&
3947 verifier.VerifyTable(base()) &&
3949 verifier.VerifyTable(descriptor()) &&
3950 verifier.EndTable();
3956 flatbuffers::FlatBufferBuilder &
fbb_;
3958 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3961 void add_descriptor(flatbuffers::Offset<armnnSerializer::LogSoftmaxDescriptor> descriptor) {
3966 start_ = fbb_.StartTable();
3969 flatbuffers::Offset<LogSoftmaxLayer>
Finish() {
3970 const auto end = fbb_.EndTable(start_);
3971 auto o = flatbuffers::Offset<LogSoftmaxLayer>(end);
3977 flatbuffers::FlatBufferBuilder &_fbb,
3978 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3979 flatbuffers::Offset<armnnSerializer::LogSoftmaxDescriptor> descriptor = 0) {
3983 return builder_.
Finish();
3988 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3993 return GetField<float>(
VT_BETA, 1.0f);
3996 return GetField<int32_t>(
VT_AXIS, -1);
3998 bool Verify(flatbuffers::Verifier &verifier)
const {
3999 return VerifyTableStart(verifier) &&
4000 VerifyField<float>(verifier,
VT_BETA) &&
4001 VerifyField<int32_t>(verifier,
VT_AXIS) &&
4002 verifier.EndTable();
4008 flatbuffers::FlatBufferBuilder &
fbb_;
4018 start_ = fbb_.StartTable();
4021 flatbuffers::Offset<LogSoftmaxDescriptor>
Finish() {
4022 const auto end = fbb_.EndTable(start_);
4023 auto o = flatbuffers::Offset<LogSoftmaxDescriptor>(end);
4029 flatbuffers::FlatBufferBuilder &_fbb,
4031 int32_t axis = -1) {
4035 return builder_.
Finish();
4038 struct L2NormalizationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4040 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4044 const armnnSerializer::LayerBase *
base()
const {
4045 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4047 const armnnSerializer::L2NormalizationDescriptor *
descriptor()
const {
4048 return GetPointer<const armnnSerializer::L2NormalizationDescriptor *>(
VT_DESCRIPTOR);
4050 bool Verify(flatbuffers::Verifier &verifier)
const {
4051 return VerifyTableStart(verifier) &&
4052 VerifyOffset(verifier,
VT_BASE) &&
4053 verifier.VerifyTable(base()) &&
4055 verifier.VerifyTable(descriptor()) &&
4056 verifier.EndTable();
4062 flatbuffers::FlatBufferBuilder &
fbb_;
4064 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4067 void add_descriptor(flatbuffers::Offset<armnnSerializer::L2NormalizationDescriptor> descriptor) {
4072 start_ = fbb_.StartTable();
4075 flatbuffers::Offset<L2NormalizationLayer>
Finish() {
4076 const auto end = fbb_.EndTable(start_);
4077 auto o = flatbuffers::Offset<L2NormalizationLayer>(end);
4083 flatbuffers::FlatBufferBuilder &_fbb,
4084 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4085 flatbuffers::Offset<armnnSerializer::L2NormalizationDescriptor> descriptor = 0) {
4089 return builder_.
Finish();
4092 struct L2NormalizationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4094 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4102 return GetField<float>(
VT_EPS, 1e-12f);
4104 bool Verify(flatbuffers::Verifier &verifier)
const {
4105 return VerifyTableStart(verifier) &&
4107 VerifyField<float>(verifier,
VT_EPS) &&
4108 verifier.EndTable();
4113 typedef L2NormalizationDescriptor
Table;
4114 flatbuffers::FlatBufferBuilder &
fbb_;
4124 start_ = fbb_.StartTable();
4127 flatbuffers::Offset<L2NormalizationDescriptor>
Finish() {
4128 const auto end = fbb_.EndTable(start_);
4129 auto o = flatbuffers::Offset<L2NormalizationDescriptor>(end);
4135 flatbuffers::FlatBufferBuilder &_fbb,
4137 float eps = 1e-12f) {
4141 return builder_.
Finish();
4144 struct LogicalBinaryDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4146 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4152 bool Verify(flatbuffers::Verifier &verifier)
const {
4153 return VerifyTableStart(verifier) &&
4154 VerifyField<int8_t>(verifier, VT_OPERATION) &&
4155 verifier.EndTable();
4161 flatbuffers::FlatBufferBuilder &
fbb_;
4164 fbb_.AddElement<int8_t>(LogicalBinaryDescriptor::VT_OPERATION,
static_cast<int8_t
>(operation), 0);
4168 start_ = fbb_.StartTable();
4171 flatbuffers::Offset<LogicalBinaryDescriptor>
Finish() {
4172 const auto end = fbb_.EndTable(start_);
4173 auto o = flatbuffers::Offset<LogicalBinaryDescriptor>(end);
4179 flatbuffers::FlatBufferBuilder &_fbb,
4183 return builder_.
Finish();
4186 struct LogicalBinaryLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4188 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4192 const armnnSerializer::LayerBase *
base()
const {
4193 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4195 const armnnSerializer::LogicalBinaryDescriptor *
descriptor()
const {
4196 return GetPointer<const armnnSerializer::LogicalBinaryDescriptor *>(
VT_DESCRIPTOR);
4198 bool Verify(flatbuffers::Verifier &verifier)
const {
4199 return VerifyTableStart(verifier) &&
4200 VerifyOffset(verifier,
VT_BASE) &&
4201 verifier.VerifyTable(base()) &&
4203 verifier.VerifyTable(descriptor()) &&
4204 verifier.EndTable();
4210 flatbuffers::FlatBufferBuilder &
fbb_;
4212 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4215 void add_descriptor(flatbuffers::Offset<armnnSerializer::LogicalBinaryDescriptor> descriptor) {
4220 start_ = fbb_.StartTable();
4223 flatbuffers::Offset<LogicalBinaryLayer>
Finish() {
4224 const auto end = fbb_.EndTable(start_);
4225 auto o = flatbuffers::Offset<LogicalBinaryLayer>(end);
4231 flatbuffers::FlatBufferBuilder &_fbb,
4232 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4233 flatbuffers::Offset<armnnSerializer::LogicalBinaryDescriptor> descriptor = 0) {
4237 return builder_.
Finish();
4240 struct MinimumLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4242 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4245 const armnnSerializer::LayerBase *
base()
const {
4246 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4248 bool Verify(flatbuffers::Verifier &verifier)
const {
4249 return VerifyTableStart(verifier) &&
4250 VerifyOffset(verifier,
VT_BASE) &&
4251 verifier.VerifyTable(base()) &&
4252 verifier.EndTable();
4258 flatbuffers::FlatBufferBuilder &
fbb_;
4260 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4265 start_ = fbb_.StartTable();
4269 const auto end = fbb_.EndTable(start_);
4270 auto o = flatbuffers::Offset<MinimumLayer>(end);
4276 flatbuffers::FlatBufferBuilder &_fbb,
4277 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4280 return builder_.
Finish();
4283 struct MaximumLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4285 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4288 const armnnSerializer::LayerBase *
base()
const {
4289 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4291 bool Verify(flatbuffers::Verifier &verifier)
const {
4292 return VerifyTableStart(verifier) &&
4293 VerifyOffset(verifier,
VT_BASE) &&
4294 verifier.VerifyTable(base()) &&
4295 verifier.EndTable();
4301 flatbuffers::FlatBufferBuilder &
fbb_;
4303 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4308 start_ = fbb_.StartTable();
4312 const auto end = fbb_.EndTable(start_);
4313 auto o = flatbuffers::Offset<MaximumLayer>(end);
4319 flatbuffers::FlatBufferBuilder &_fbb,
4320 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4323 return builder_.
Finish();
4326 struct MultiplicationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4328 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4331 const armnnSerializer::LayerBase *
base()
const {
4332 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4334 bool Verify(flatbuffers::Verifier &verifier)
const {
4335 return VerifyTableStart(verifier) &&
4336 VerifyOffset(verifier,
VT_BASE) &&
4337 verifier.VerifyTable(base()) &&
4338 verifier.EndTable();
4344 flatbuffers::FlatBufferBuilder &
fbb_;
4346 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4351 start_ = fbb_.StartTable();
4354 flatbuffers::Offset<MultiplicationLayer>
Finish() {
4355 const auto end = fbb_.EndTable(start_);
4356 auto o = flatbuffers::Offset<MultiplicationLayer>(end);
4362 flatbuffers::FlatBufferBuilder &_fbb,
4363 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4366 return builder_.
Finish();
4369 struct Pooling2dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4371 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4375 const armnnSerializer::LayerBase *
base()
const {
4376 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4379 return GetPointer<const armnnSerializer::Pooling2dDescriptor *>(
VT_DESCRIPTOR);
4381 bool Verify(flatbuffers::Verifier &verifier)
const {
4382 return VerifyTableStart(verifier) &&
4383 VerifyOffset(verifier,
VT_BASE) &&
4384 verifier.VerifyTable(base()) &&
4386 verifier.VerifyTable(descriptor()) &&
4387 verifier.EndTable();
4393 flatbuffers::FlatBufferBuilder &
fbb_;
4395 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4398 void add_descriptor(flatbuffers::Offset<armnnSerializer::Pooling2dDescriptor> descriptor) {
4403 start_ = fbb_.StartTable();
4406 flatbuffers::Offset<Pooling2dLayer>
Finish() {
4407 const auto end = fbb_.EndTable(start_);
4408 auto o = flatbuffers::Offset<Pooling2dLayer>(end);
4414 flatbuffers::FlatBufferBuilder &_fbb,
4415 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4416 flatbuffers::Offset<armnnSerializer::Pooling2dDescriptor> descriptor = 0) {
4420 return builder_.
Finish();
4423 struct Pooling2dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4425 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4449 return GetField<uint32_t>(
VT_PADTOP, 0);
4475 bool Verify(flatbuffers::Verifier &verifier)
const {
4476 return VerifyTableStart(verifier) &&
4478 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
4480 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
4484 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
4485 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
4489 verifier.EndTable();
4495 flatbuffers::FlatBufferBuilder &
fbb_;
4535 start_ = fbb_.StartTable();
4538 flatbuffers::Offset<Pooling2dDescriptor>
Finish() {
4539 const auto end = fbb_.EndTable(start_);
4540 auto o = flatbuffers::Offset<Pooling2dDescriptor>(end);
4546 flatbuffers::FlatBufferBuilder &_fbb,
4548 uint32_t padLeft = 0,
4549 uint32_t padRight = 0,
4550 uint32_t padTop = 0,
4551 uint32_t padBottom = 0,
4552 uint32_t poolWidth = 0,
4553 uint32_t poolHeight = 0,
4554 uint32_t strideX = 0,
4555 uint32_t strideY = 0,
4572 return builder_.
Finish();
4575 struct QuantizeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4577 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4580 const armnnSerializer::LayerBase *
base()
const {
4581 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4583 bool Verify(flatbuffers::Verifier &verifier)
const {
4584 return VerifyTableStart(verifier) &&
4585 VerifyOffset(verifier,
VT_BASE) &&
4586 verifier.VerifyTable(base()) &&
4587 verifier.EndTable();
4593 flatbuffers::FlatBufferBuilder &
fbb_;
4595 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4600 start_ = fbb_.StartTable();
4603 flatbuffers::Offset<QuantizeLayer>
Finish() {
4604 const auto end = fbb_.EndTable(start_);
4605 auto o = flatbuffers::Offset<QuantizeLayer>(end);
4611 flatbuffers::FlatBufferBuilder &_fbb,
4612 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4615 return builder_.
Finish();
4618 struct SoftmaxLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4620 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4624 const armnnSerializer::LayerBase *
base()
const {
4625 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4628 return GetPointer<const armnnSerializer::SoftmaxDescriptor *>(
VT_DESCRIPTOR);
4630 bool Verify(flatbuffers::Verifier &verifier)
const {
4631 return VerifyTableStart(verifier) &&
4632 VerifyOffset(verifier,
VT_BASE) &&
4633 verifier.VerifyTable(base()) &&
4635 verifier.VerifyTable(descriptor()) &&
4636 verifier.EndTable();
4642 flatbuffers::FlatBufferBuilder &
fbb_;
4644 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4647 void add_descriptor(flatbuffers::Offset<armnnSerializer::SoftmaxDescriptor> descriptor) {
4652 start_ = fbb_.StartTable();
4656 const auto end = fbb_.EndTable(start_);
4657 auto o = flatbuffers::Offset<SoftmaxLayer>(end);
4663 flatbuffers::FlatBufferBuilder &_fbb,
4664 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4665 flatbuffers::Offset<armnnSerializer::SoftmaxDescriptor> descriptor = 0) {
4669 return builder_.
Finish();
4672 struct SoftmaxDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4674 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4678 return GetField<float>(
VT_BETA, 0.0f);
4680 bool Verify(flatbuffers::Verifier &verifier)
const {
4681 return VerifyTableStart(verifier) &&
4682 VerifyField<float>(verifier,
VT_BETA) &&
4683 verifier.EndTable();
4689 flatbuffers::FlatBufferBuilder &
fbb_;
4696 start_ = fbb_.StartTable();
4699 flatbuffers::Offset<SoftmaxDescriptor>
Finish() {
4700 const auto end = fbb_.EndTable(start_);
4701 auto o = flatbuffers::Offset<SoftmaxDescriptor>(end);
4707 flatbuffers::FlatBufferBuilder &_fbb,
4708 float beta = 0.0f) {
4711 return builder_.
Finish();
4714 struct DepthwiseConvolution2dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4716 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4722 const armnnSerializer::LayerBase *
base()
const {
4723 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4725 const armnnSerializer::DepthwiseConvolution2dDescriptor *
descriptor()
const {
4726 return GetPointer<const armnnSerializer::DepthwiseConvolution2dDescriptor *>(
VT_DESCRIPTOR);
4728 const armnnSerializer::ConstTensor *
weights()
const {
4729 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_WEIGHTS);
4731 const armnnSerializer::ConstTensor *
biases()
const {
4732 return GetPointer<const armnnSerializer::ConstTensor *>(VT_BIASES);
4734 bool Verify(flatbuffers::Verifier &verifier)
const {
4735 return VerifyTableStart(verifier) &&
4736 VerifyOffset(verifier,
VT_BASE) &&
4737 verifier.VerifyTable(base()) &&
4739 verifier.VerifyTable(descriptor()) &&
4741 verifier.VerifyTable(weights()) &&
4742 VerifyOffset(verifier, VT_BIASES) &&
4743 verifier.VerifyTable(biases()) &&
4744 verifier.EndTable();
4749 typedef DepthwiseConvolution2dLayer
Table;
4750 flatbuffers::FlatBufferBuilder &
fbb_;
4752 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4755 void add_descriptor(flatbuffers::Offset<armnnSerializer::DepthwiseConvolution2dDescriptor> descriptor) {
4758 void add_weights(flatbuffers::Offset<armnnSerializer::ConstTensor> weights) {
4761 void add_biases(flatbuffers::Offset<armnnSerializer::ConstTensor> biases) {
4762 fbb_.AddOffset(DepthwiseConvolution2dLayer::VT_BIASES, biases);
4766 start_ = fbb_.StartTable();
4769 flatbuffers::Offset<DepthwiseConvolution2dLayer>
Finish() {
4770 const auto end = fbb_.EndTable(start_);
4771 auto o = flatbuffers::Offset<DepthwiseConvolution2dLayer>(end);
4777 flatbuffers::FlatBufferBuilder &_fbb,
4778 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4779 flatbuffers::Offset<armnnSerializer::DepthwiseConvolution2dDescriptor> descriptor = 0,
4780 flatbuffers::Offset<armnnSerializer::ConstTensor> weights = 0,
4781 flatbuffers::Offset<armnnSerializer::ConstTensor> biases = 0) {
4787 return builder_.
Finish();
4790 struct DepthwiseConvolution2dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4792 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4811 return GetField<uint32_t>(
VT_PADTOP, 0);
4834 bool Verify(flatbuffers::Verifier &verifier)
const {
4835 return VerifyTableStart(verifier) &&
4836 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
4838 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
4840 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
4841 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
4846 verifier.EndTable();
4851 typedef DepthwiseConvolution2dDescriptor
Table;
4852 flatbuffers::FlatBufferBuilder &
fbb_;
4886 start_ = fbb_.StartTable();
4889 flatbuffers::Offset<DepthwiseConvolution2dDescriptor>
Finish() {
4890 const auto end = fbb_.EndTable(start_);
4891 auto o = flatbuffers::Offset<DepthwiseConvolution2dDescriptor>(end);
4897 flatbuffers::FlatBufferBuilder &_fbb,
4898 uint32_t padLeft = 0,
4899 uint32_t padRight = 0,
4900 uint32_t padTop = 0,
4901 uint32_t padBottom = 0,
4902 uint32_t strideX = 0,
4903 uint32_t strideY = 0,
4904 uint32_t dilationX = 1,
4905 uint32_t dilationY = 1,
4906 bool biasEnabled =
false,
4919 return builder_.
Finish();
4922 struct OutputLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4924 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4927 const armnnSerializer::BindableLayerBase *
base()
const {
4928 return GetPointer<const armnnSerializer::BindableLayerBase *>(
VT_BASE);
4930 bool Verify(flatbuffers::Verifier &verifier)
const {
4931 return VerifyTableStart(verifier) &&
4932 VerifyOffset(verifier,
VT_BASE) &&
4933 verifier.VerifyTable(base()) &&
4934 verifier.EndTable();
4940 flatbuffers::FlatBufferBuilder &
fbb_;
4942 void add_base(flatbuffers::Offset<armnnSerializer::BindableLayerBase> base) {
4947 start_ = fbb_.StartTable();
4951 const auto end = fbb_.EndTable(start_);
4952 auto o = flatbuffers::Offset<OutputLayer>(end);
4958 flatbuffers::FlatBufferBuilder &_fbb,
4959 flatbuffers::Offset<armnnSerializer::BindableLayerBase> base = 0) {
4962 return builder_.
Finish();
4965 struct ReshapeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4967 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4971 const armnnSerializer::LayerBase *
base()
const {
4972 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4975 return GetPointer<const armnnSerializer::ReshapeDescriptor *>(
VT_DESCRIPTOR);
4977 bool Verify(flatbuffers::Verifier &verifier)
const {
4978 return VerifyTableStart(verifier) &&
4979 VerifyOffset(verifier,
VT_BASE) &&
4980 verifier.VerifyTable(base()) &&
4982 verifier.VerifyTable(descriptor()) &&
4983 verifier.EndTable();
4989 flatbuffers::FlatBufferBuilder &
fbb_;
4991 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4994 void add_descriptor(flatbuffers::Offset<armnnSerializer::ReshapeDescriptor> descriptor) {
4999 start_ = fbb_.StartTable();
5003 const auto end = fbb_.EndTable(start_);
5004 auto o = flatbuffers::Offset<ReshapeLayer>(end);
5010 flatbuffers::FlatBufferBuilder &_fbb,
5011 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5012 flatbuffers::Offset<armnnSerializer::ReshapeDescriptor> descriptor = 0) {
5016 return builder_.
Finish();
5019 struct ReshapeDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5021 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5025 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_TARGETSHAPE);
5027 bool Verify(flatbuffers::Verifier &verifier)
const {
5028 return VerifyTableStart(verifier) &&
5029 VerifyOffset(verifier, VT_TARGETSHAPE) &&
5030 verifier.VerifyVector(targetShape()) &&
5031 verifier.EndTable();
5037 flatbuffers::FlatBufferBuilder &
fbb_;
5040 fbb_.AddOffset(ReshapeDescriptor::VT_TARGETSHAPE, targetShape);
5044 start_ = fbb_.StartTable();
5047 flatbuffers::Offset<ReshapeDescriptor>
Finish() {
5048 const auto end = fbb_.EndTable(start_);
5049 auto o = flatbuffers::Offset<ReshapeDescriptor>(end);
5055 flatbuffers::FlatBufferBuilder &_fbb,
5059 return builder_.
Finish();
5063 flatbuffers::FlatBufferBuilder &_fbb,
5064 const std::vector<uint32_t> *targetShape =
nullptr) {
5065 auto targetShape__ = targetShape ? _fbb.CreateVector<uint32_t>(*targetShape) : 0;
5071 struct PermuteLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5073 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5077 const armnnSerializer::LayerBase *
base()
const {
5078 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5081 return GetPointer<const armnnSerializer::PermuteDescriptor *>(
VT_DESCRIPTOR);
5083 bool Verify(flatbuffers::Verifier &verifier)
const {
5084 return VerifyTableStart(verifier) &&
5085 VerifyOffset(verifier,
VT_BASE) &&
5086 verifier.VerifyTable(base()) &&
5088 verifier.VerifyTable(descriptor()) &&
5089 verifier.EndTable();
5095 flatbuffers::FlatBufferBuilder &
fbb_;
5097 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5100 void add_descriptor(flatbuffers::Offset<armnnSerializer::PermuteDescriptor> descriptor) {
5105 start_ = fbb_.StartTable();
5109 const auto end = fbb_.EndTable(start_);
5110 auto o = flatbuffers::Offset<PermuteLayer>(end);
5116 flatbuffers::FlatBufferBuilder &_fbb,
5117 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5118 flatbuffers::Offset<armnnSerializer::PermuteDescriptor> descriptor = 0) {
5122 return builder_.
Finish();
5125 struct PermuteDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5127 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5131 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DIMMAPPINGS);
5133 bool Verify(flatbuffers::Verifier &verifier)
const {
5134 return VerifyTableStart(verifier) &&
5135 VerifyOffset(verifier, VT_DIMMAPPINGS) &&
5136 verifier.VerifyVector(dimMappings()) &&
5137 verifier.EndTable();
5143 flatbuffers::FlatBufferBuilder &
fbb_;
5146 fbb_.AddOffset(PermuteDescriptor::VT_DIMMAPPINGS, dimMappings);
5150 start_ = fbb_.StartTable();
5153 flatbuffers::Offset<PermuteDescriptor>
Finish() {
5154 const auto end = fbb_.EndTable(start_);
5155 auto o = flatbuffers::Offset<PermuteDescriptor>(end);
5161 flatbuffers::FlatBufferBuilder &_fbb,
5165 return builder_.
Finish();
5169 flatbuffers::FlatBufferBuilder &_fbb,
5170 const std::vector<uint32_t> *dimMappings =
nullptr) {
5171 auto dimMappings__ = dimMappings ? _fbb.CreateVector<uint32_t>(*dimMappings) : 0;
5177 struct SpaceToBatchNdLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5179 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5183 const armnnSerializer::LayerBase *
base()
const {
5184 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5186 const armnnSerializer::SpaceToBatchNdDescriptor *
descriptor()
const {
5187 return GetPointer<const armnnSerializer::SpaceToBatchNdDescriptor *>(
VT_DESCRIPTOR);
5189 bool Verify(flatbuffers::Verifier &verifier)
const {
5190 return VerifyTableStart(verifier) &&
5191 VerifyOffset(verifier,
VT_BASE) &&
5192 verifier.VerifyTable(base()) &&
5194 verifier.VerifyTable(descriptor()) &&
5195 verifier.EndTable();
5201 flatbuffers::FlatBufferBuilder &
fbb_;
5203 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5206 void add_descriptor(flatbuffers::Offset<armnnSerializer::SpaceToBatchNdDescriptor> descriptor) {
5211 start_ = fbb_.StartTable();
5214 flatbuffers::Offset<SpaceToBatchNdLayer>
Finish() {
5215 const auto end = fbb_.EndTable(start_);
5216 auto o = flatbuffers::Offset<SpaceToBatchNdLayer>(end);
5222 flatbuffers::FlatBufferBuilder &_fbb,
5223 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5224 flatbuffers::Offset<armnnSerializer::SpaceToBatchNdDescriptor> descriptor = 0) {
5228 return builder_.
Finish();
5231 struct SpaceToBatchNdDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5233 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5239 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_BLOCKSHAPE);
5241 const flatbuffers::Vector<uint32_t> *
padList()
const {
5242 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_PADLIST);
5247 bool Verify(flatbuffers::Verifier &verifier)
const {
5248 return VerifyTableStart(verifier) &&
5250 verifier.VerifyVector(blockShape()) &&
5252 verifier.VerifyVector(padList()) &&
5254 verifier.EndTable();
5260 flatbuffers::FlatBufferBuilder &
fbb_;
5273 start_ = fbb_.StartTable();
5276 flatbuffers::Offset<SpaceToBatchNdDescriptor>
Finish() {
5277 const auto end = fbb_.EndTable(start_);
5278 auto o = flatbuffers::Offset<SpaceToBatchNdDescriptor>(end);
5284 flatbuffers::FlatBufferBuilder &_fbb,
5292 return builder_.
Finish();
5296 flatbuffers::FlatBufferBuilder &_fbb,
5297 const std::vector<uint32_t> *blockShape =
nullptr,
5298 const std::vector<uint32_t> *padList =
nullptr,
5300 auto blockShape__ = blockShape ? _fbb.CreateVector<uint32_t>(*blockShape) : 0;
5301 auto padList__ = padList ? _fbb.CreateVector<uint32_t>(*padList) : 0;
5309 struct SpaceToDepthLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5311 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5315 const armnnSerializer::LayerBase *
base()
const {
5316 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5318 const armnnSerializer::SpaceToDepthDescriptor *
descriptor()
const {
5319 return GetPointer<const armnnSerializer::SpaceToDepthDescriptor *>(
VT_DESCRIPTOR);
5321 bool Verify(flatbuffers::Verifier &verifier)
const {
5322 return VerifyTableStart(verifier) &&
5323 VerifyOffset(verifier,
VT_BASE) &&
5324 verifier.VerifyTable(base()) &&
5326 verifier.VerifyTable(descriptor()) &&
5327 verifier.EndTable();
5333 flatbuffers::FlatBufferBuilder &
fbb_;
5335 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5338 void add_descriptor(flatbuffers::Offset<armnnSerializer::SpaceToDepthDescriptor> descriptor) {
5343 start_ = fbb_.StartTable();
5346 flatbuffers::Offset<SpaceToDepthLayer>
Finish() {
5347 const auto end = fbb_.EndTable(start_);
5348 auto o = flatbuffers::Offset<SpaceToDepthLayer>(end);
5354 flatbuffers::FlatBufferBuilder &_fbb,
5355 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5356 flatbuffers::Offset<armnnSerializer::SpaceToDepthDescriptor> descriptor = 0) {
5360 return builder_.
Finish();
5363 struct SpaceToDepthDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5365 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5375 bool Verify(flatbuffers::Verifier &verifier)
const {
5376 return VerifyTableStart(verifier) &&
5379 verifier.EndTable();
5385 flatbuffers::FlatBufferBuilder &
fbb_;
5395 start_ = fbb_.StartTable();
5398 flatbuffers::Offset<SpaceToDepthDescriptor>
Finish() {
5399 const auto end = fbb_.EndTable(start_);
5400 auto o = flatbuffers::Offset<SpaceToDepthDescriptor>(end);
5406 flatbuffers::FlatBufferBuilder &_fbb,
5407 uint32_t blockSize = 0,
5412 return builder_.
Finish();
5415 struct SubtractionLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5417 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5420 const armnnSerializer::LayerBase *
base()
const {
5421 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5423 bool Verify(flatbuffers::Verifier &verifier)
const {
5424 return VerifyTableStart(verifier) &&
5425 VerifyOffset(verifier,
VT_BASE) &&
5426 verifier.VerifyTable(base()) &&
5427 verifier.EndTable();
5433 flatbuffers::FlatBufferBuilder &
fbb_;
5435 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5440 start_ = fbb_.StartTable();
5443 flatbuffers::Offset<SubtractionLayer>
Finish() {
5444 const auto end = fbb_.EndTable(start_);
5445 auto o = flatbuffers::Offset<SubtractionLayer>(end);
5451 flatbuffers::FlatBufferBuilder &_fbb,
5452 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
5455 return builder_.
Finish();
5458 struct BatchToSpaceNdLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5460 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5464 const armnnSerializer::LayerBase *
base()
const {
5465 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5467 const armnnSerializer::BatchToSpaceNdDescriptor *
descriptor()
const {
5468 return GetPointer<const armnnSerializer::BatchToSpaceNdDescriptor *>(
VT_DESCRIPTOR);
5470 bool Verify(flatbuffers::Verifier &verifier)
const {
5471 return VerifyTableStart(verifier) &&
5472 VerifyOffset(verifier,
VT_BASE) &&
5473 verifier.VerifyTable(base()) &&
5475 verifier.VerifyTable(descriptor()) &&
5476 verifier.EndTable();
5482 flatbuffers::FlatBufferBuilder &
fbb_;
5484 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5487 void add_descriptor(flatbuffers::Offset<armnnSerializer::BatchToSpaceNdDescriptor> descriptor) {
5492 start_ = fbb_.StartTable();
5495 flatbuffers::Offset<BatchToSpaceNdLayer>
Finish() {
5496 const auto end = fbb_.EndTable(start_);
5497 auto o = flatbuffers::Offset<BatchToSpaceNdLayer>(end);
5503 flatbuffers::FlatBufferBuilder &_fbb,
5504 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5505 flatbuffers::Offset<armnnSerializer::BatchToSpaceNdDescriptor> descriptor = 0) {
5509 return builder_.
Finish();
5512 struct BatchToSpaceNdDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5514 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5520 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_BLOCKSHAPE);
5522 const flatbuffers::Vector<uint32_t> *
crops()
const {
5523 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_CROPS);
5528 bool Verify(flatbuffers::Verifier &verifier)
const {
5529 return VerifyTableStart(verifier) &&
5531 verifier.VerifyVector(blockShape()) &&
5532 VerifyOffset(verifier,
VT_CROPS) &&
5533 verifier.VerifyVector(crops()) &&
5535 verifier.EndTable();
5541 flatbuffers::FlatBufferBuilder &
fbb_;
5554 start_ = fbb_.StartTable();
5557 flatbuffers::Offset<BatchToSpaceNdDescriptor>
Finish() {
5558 const auto end = fbb_.EndTable(start_);
5559 auto o = flatbuffers::Offset<BatchToSpaceNdDescriptor>(end);
5565 flatbuffers::FlatBufferBuilder &_fbb,
5573 return builder_.
Finish();
5577 flatbuffers::FlatBufferBuilder &_fbb,
5578 const std::vector<uint32_t> *blockShape =
nullptr,
5579 const std::vector<uint32_t> *crops =
nullptr,
5581 auto blockShape__ = blockShape ? _fbb.CreateVector<uint32_t>(*blockShape) : 0;
5582 auto crops__ = crops ? _fbb.CreateVector<uint32_t>(*crops) : 0;
5590 struct NormalizationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5592 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5596 const armnnSerializer::LayerBase *
base()
const {
5597 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5599 const armnnSerializer::NormalizationDescriptor *
descriptor()
const {
5600 return GetPointer<const armnnSerializer::NormalizationDescriptor *>(
VT_DESCRIPTOR);
5602 bool Verify(flatbuffers::Verifier &verifier)
const {
5603 return VerifyTableStart(verifier) &&
5604 VerifyOffset(verifier,
VT_BASE) &&
5605 verifier.VerifyTable(base()) &&
5607 verifier.VerifyTable(descriptor()) &&
5608 verifier.EndTable();
5614 flatbuffers::FlatBufferBuilder &
fbb_;
5616 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5619 void add_descriptor(flatbuffers::Offset<armnnSerializer::NormalizationDescriptor> descriptor) {
5624 start_ = fbb_.StartTable();
5627 flatbuffers::Offset<NormalizationLayer>
Finish() {
5628 const auto end = fbb_.EndTable(start_);
5629 auto o = flatbuffers::Offset<NormalizationLayer>(end);
5635 flatbuffers::FlatBufferBuilder &_fbb,
5636 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5637 flatbuffers::Offset<armnnSerializer::NormalizationDescriptor> descriptor = 0) {
5641 return builder_.
Finish();
5644 struct NormalizationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5646 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5665 return GetField<float>(
VT_ALPHA, 0.0f);
5668 return GetField<float>(
VT_BETA, 0.0f);
5671 return GetField<float>(
VT_K, 0.0f);
5676 bool Verify(flatbuffers::Verifier &verifier)
const {
5677 return VerifyTableStart(verifier) &&
5681 VerifyField<float>(verifier,
VT_ALPHA) &&
5682 VerifyField<float>(verifier,
VT_BETA) &&
5683 VerifyField<float>(verifier,
VT_K) &&
5685 verifier.EndTable();
5691 flatbuffers::FlatBufferBuilder &
fbb_;
5716 start_ = fbb_.StartTable();
5719 flatbuffers::Offset<NormalizationDescriptor>
Finish() {
5720 const auto end = fbb_.EndTable(start_);
5721 auto o = flatbuffers::Offset<NormalizationDescriptor>(end);
5727 flatbuffers::FlatBufferBuilder &_fbb,
5730 uint32_t normSize = 0,
5743 return builder_.
Finish();
5746 struct MeanLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5748 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5752 const armnnSerializer::LayerBase *
base()
const {
5753 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5756 return GetPointer<const armnnSerializer::MeanDescriptor *>(
VT_DESCRIPTOR);
5758 bool Verify(flatbuffers::Verifier &verifier)
const {
5759 return VerifyTableStart(verifier) &&
5760 VerifyOffset(verifier,
VT_BASE) &&
5761 verifier.VerifyTable(base()) &&
5763 verifier.VerifyTable(descriptor()) &&
5764 verifier.EndTable();
5770 flatbuffers::FlatBufferBuilder &
fbb_;
5772 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5775 void add_descriptor(flatbuffers::Offset<armnnSerializer::MeanDescriptor> descriptor) {
5780 start_ = fbb_.StartTable();
5784 const auto end = fbb_.EndTable(start_);
5785 auto o = flatbuffers::Offset<MeanLayer>(end);
5791 flatbuffers::FlatBufferBuilder &_fbb,
5792 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5793 flatbuffers::Offset<armnnSerializer::MeanDescriptor> descriptor = 0) {
5797 return builder_.
Finish();
5800 struct MeanDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5802 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5806 const flatbuffers::Vector<uint32_t> *
axis()
const {
5807 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_AXIS);
5812 bool Verify(flatbuffers::Verifier &verifier)
const {
5813 return VerifyTableStart(verifier) &&
5814 VerifyOffset(verifier,
VT_AXIS) &&
5815 verifier.VerifyVector(axis()) &&
5817 verifier.EndTable();
5823 flatbuffers::FlatBufferBuilder &
fbb_;
5833 start_ = fbb_.StartTable();
5836 flatbuffers::Offset<MeanDescriptor>
Finish() {
5837 const auto end = fbb_.EndTable(start_);
5838 auto o = flatbuffers::Offset<MeanDescriptor>(end);
5844 flatbuffers::FlatBufferBuilder &_fbb,
5846 bool keepDims =
false) {
5850 return builder_.
Finish();
5854 flatbuffers::FlatBufferBuilder &_fbb,
5855 const std::vector<uint32_t> *axis =
nullptr,
5856 bool keepDims =
false) {
5857 auto axis__ = axis ? _fbb.CreateVector<uint32_t>(*axis) : 0;
5864 struct PadLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5866 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5870 const armnnSerializer::LayerBase *
base()
const {
5871 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5874 return GetPointer<const armnnSerializer::PadDescriptor *>(
VT_DESCRIPTOR);
5876 bool Verify(flatbuffers::Verifier &verifier)
const {
5877 return VerifyTableStart(verifier) &&
5878 VerifyOffset(verifier,
VT_BASE) &&
5879 verifier.VerifyTable(base()) &&
5881 verifier.VerifyTable(descriptor()) &&
5882 verifier.EndTable();
5888 flatbuffers::FlatBufferBuilder &
fbb_;
5890 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5893 void add_descriptor(flatbuffers::Offset<armnnSerializer::PadDescriptor> descriptor) {
5898 start_ = fbb_.StartTable();
5902 const auto end = fbb_.EndTable(start_);
5903 auto o = flatbuffers::Offset<PadLayer>(end);
5909 flatbuffers::FlatBufferBuilder &_fbb,
5910 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5911 flatbuffers::Offset<armnnSerializer::PadDescriptor> descriptor = 0) {
5915 return builder_.
Finish();
5918 struct PadDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5920 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5924 const flatbuffers::Vector<uint32_t> *
padList()
const {
5925 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_PADLIST);
5928 return GetField<float>(VT_PADVALUE, 0.0f);
5930 bool Verify(flatbuffers::Verifier &verifier)
const {
5931 return VerifyTableStart(verifier) &&
5933 verifier.VerifyVector(padList()) &&
5934 VerifyField<float>(verifier, VT_PADVALUE) &&
5935 verifier.EndTable();
5941 flatbuffers::FlatBufferBuilder &
fbb_;
5947 fbb_.AddElement<
float>(PadDescriptor::VT_PADVALUE, padValue, 0.0f);
5951 start_ = fbb_.StartTable();
5954 flatbuffers::Offset<PadDescriptor>
Finish() {
5955 const auto end = fbb_.EndTable(start_);
5956 auto o = flatbuffers::Offset<PadDescriptor>(end);
5962 flatbuffers::FlatBufferBuilder &_fbb,
5964 float padValue = 0.0f) {
5968 return builder_.
Finish();
5972 flatbuffers::FlatBufferBuilder &_fbb,
5973 const std::vector<uint32_t> *padList =
nullptr,
5974 float padValue = 0.0f) {
5975 auto padList__ = padList ? _fbb.CreateVector<uint32_t>(*padList) : 0;
5983 struct RsqrtLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5985 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5988 const armnnSerializer::LayerBase *
base()
const {
5989 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5991 bool Verify(flatbuffers::Verifier &verifier)
const {
5992 return VerifyTableStart(verifier) &&
5993 VerifyOffset(verifier,
VT_BASE) &&
5994 verifier.VerifyTable(base()) &&
5995 verifier.EndTable();
6001 flatbuffers::FlatBufferBuilder &
fbb_;
6003 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6008 start_ = fbb_.StartTable();
6012 const auto end = fbb_.EndTable(start_);
6013 auto o = flatbuffers::Offset<RsqrtLayer>(end);
6019 flatbuffers::FlatBufferBuilder &_fbb,
6020 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
6023 return builder_.
Finish();
6026 struct BatchNormalizationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6028 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6036 const armnnSerializer::LayerBase *
base()
const {
6037 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6039 const armnnSerializer::BatchNormalizationDescriptor *
descriptor()
const {
6040 return GetPointer<const armnnSerializer::BatchNormalizationDescriptor *>(
VT_DESCRIPTOR);
6042 const armnnSerializer::ConstTensor *
mean()
const {
6043 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_MEAN);
6046 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_VARIANCE);
6048 const armnnSerializer::ConstTensor *
beta()
const {
6049 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_BETA);
6051 const armnnSerializer::ConstTensor *
gamma()
const {
6052 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_GAMMA);
6054 bool Verify(flatbuffers::Verifier &verifier)
const {
6055 return VerifyTableStart(verifier) &&
6056 VerifyOffset(verifier,
VT_BASE) &&
6057 verifier.VerifyTable(base()) &&
6059 verifier.VerifyTable(descriptor()) &&
6060 VerifyOffset(verifier,
VT_MEAN) &&
6061 verifier.VerifyTable(mean()) &&
6063 verifier.VerifyTable(variance()) &&
6064 VerifyOffset(verifier,
VT_BETA) &&
6065 verifier.VerifyTable(beta()) &&
6066 VerifyOffset(verifier,
VT_GAMMA) &&
6067 verifier.VerifyTable(gamma()) &&
6068 verifier.EndTable();
6074 flatbuffers::FlatBufferBuilder &
fbb_;
6076 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6079 void add_descriptor(flatbuffers::Offset<armnnSerializer::BatchNormalizationDescriptor> descriptor) {
6082 void add_mean(flatbuffers::Offset<armnnSerializer::ConstTensor> mean) {
6085 void add_variance(flatbuffers::Offset<armnnSerializer::ConstTensor> variance) {
6088 void add_beta(flatbuffers::Offset<armnnSerializer::ConstTensor> beta) {
6091 void add_gamma(flatbuffers::Offset<armnnSerializer::ConstTensor> gamma) {
6096 start_ = fbb_.StartTable();
6099 flatbuffers::Offset<BatchNormalizationLayer>
Finish() {
6100 const auto end = fbb_.EndTable(start_);
6101 auto o = flatbuffers::Offset<BatchNormalizationLayer>(end);
6107 flatbuffers::FlatBufferBuilder &_fbb,
6108 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6109 flatbuffers::Offset<armnnSerializer::BatchNormalizationDescriptor> descriptor = 0,
6110 flatbuffers::Offset<armnnSerializer::ConstTensor> mean = 0,
6111 flatbuffers::Offset<armnnSerializer::ConstTensor> variance = 0,
6112 flatbuffers::Offset<armnnSerializer::ConstTensor> beta = 0,
6113 flatbuffers::Offset<armnnSerializer::ConstTensor> gamma = 0) {
6121 return builder_.
Finish();
6124 struct BatchNormalizationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6126 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6131 return GetField<float>(
VT_EPS, 0.0f);
6136 bool Verify(flatbuffers::Verifier &verifier)
const {
6137 return VerifyTableStart(verifier) &&
6138 VerifyField<float>(verifier,
VT_EPS) &&
6140 verifier.EndTable();
6145 typedef BatchNormalizationDescriptor
Table;
6146 flatbuffers::FlatBufferBuilder &
fbb_;
6156 start_ = fbb_.StartTable();
6159 flatbuffers::Offset<BatchNormalizationDescriptor>
Finish() {
6160 const auto end = fbb_.EndTable(start_);
6161 auto o = flatbuffers::Offset<BatchNormalizationDescriptor>(end);
6167 flatbuffers::FlatBufferBuilder &_fbb,
6173 return builder_.
Finish();
6177 struct ResizeBilinearLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6179 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6183 const armnnSerializer::LayerBase *
base()
const {
6184 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6186 const armnnSerializer::ResizeBilinearDescriptor *
descriptor()
const {
6187 return GetPointer<const armnnSerializer::ResizeBilinearDescriptor *>(
VT_DESCRIPTOR);
6189 bool Verify(flatbuffers::Verifier &verifier)
const {
6190 return VerifyTableStart(verifier) &&
6191 VerifyOffset(verifier,
VT_BASE) &&
6192 verifier.VerifyTable(base()) &&
6194 verifier.VerifyTable(descriptor()) &&
6195 verifier.EndTable();
6201 flatbuffers::FlatBufferBuilder &
fbb_;
6203 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6206 void add_descriptor(flatbuffers::Offset<armnnSerializer::ResizeBilinearDescriptor> descriptor) {
6211 start_ = fbb_.StartTable();
6214 flatbuffers::Offset<ResizeBilinearLayer>
Finish() {
6215 const auto end = fbb_.EndTable(start_);
6216 auto o = flatbuffers::Offset<ResizeBilinearLayer>(end);
6222 flatbuffers::FlatBufferBuilder &_fbb,
6223 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6224 flatbuffers::Offset<armnnSerializer::ResizeBilinearDescriptor> descriptor = 0) {
6228 return builder_.
Finish();
6231 struct ResizeBilinearDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6233 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6238 VT_HALFPIXELCENTERS = 12
6253 return GetField<uint8_t>(VT_HALFPIXELCENTERS, 0) != 0;
6255 bool Verify(flatbuffers::Verifier &verifier)
const {
6256 return VerifyTableStart(verifier) &&
6261 VerifyField<uint8_t>(verifier, VT_HALFPIXELCENTERS) &&
6262 verifier.EndTable();
6268 flatbuffers::FlatBufferBuilder &
fbb_;
6283 fbb_.AddElement<uint8_t>(ResizeBilinearDescriptor::VT_HALFPIXELCENTERS,
static_cast<uint8_t
>(halfPixelCenters), 0);
6287 start_ = fbb_.StartTable();
6290 flatbuffers::Offset<ResizeBilinearDescriptor>
Finish() {
6291 const auto end = fbb_.EndTable(start_);
6292 auto o = flatbuffers::Offset<ResizeBilinearDescriptor>(end);
6298 flatbuffers::FlatBufferBuilder &_fbb,
6299 uint32_t targetWidth = 0,
6300 uint32_t targetHeight = 0,
6302 bool alignCorners =
false,
6303 bool halfPixelCenters =
false) {
6310 return builder_.
Finish();
6313 struct SliceLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6315 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6319 const armnnSerializer::LayerBase *
base()
const {
6320 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6323 return GetPointer<const armnnSerializer::SliceDescriptor *>(
VT_DESCRIPTOR);
6325 bool Verify(flatbuffers::Verifier &verifier)
const {
6326 return VerifyTableStart(verifier) &&
6327 VerifyOffset(verifier,
VT_BASE) &&
6328 verifier.VerifyTable(base()) &&
6330 verifier.VerifyTable(descriptor()) &&
6331 verifier.EndTable();
6337 flatbuffers::FlatBufferBuilder &
fbb_;
6339 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6342 void add_descriptor(flatbuffers::Offset<armnnSerializer::SliceDescriptor> descriptor) {
6347 start_ = fbb_.StartTable();
6351 const auto end = fbb_.EndTable(start_);
6352 auto o = flatbuffers::Offset<SliceLayer>(end);
6358 flatbuffers::FlatBufferBuilder &_fbb,
6359 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6360 flatbuffers::Offset<armnnSerializer::SliceDescriptor> descriptor = 0) {
6364 return builder_.
Finish();
6367 struct SliceDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6369 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6373 const flatbuffers::Vector<uint32_t> *
begin()
const {
6374 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_BEGIN);
6376 const flatbuffers::Vector<uint32_t> *
size()
const {
6377 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_SIZE);
6379 bool Verify(flatbuffers::Verifier &verifier)
const {
6380 return VerifyTableStart(verifier) &&
6381 VerifyOffset(verifier,
VT_BEGIN) &&
6382 verifier.VerifyVector(begin()) &&
6383 VerifyOffset(verifier, VT_SIZE) &&
6384 verifier.VerifyVector(size()) &&
6385 verifier.EndTable();
6391 flatbuffers::FlatBufferBuilder &
fbb_;
6397 fbb_.AddOffset(SliceDescriptor::VT_SIZE, size);
6401 start_ = fbb_.StartTable();
6404 flatbuffers::Offset<SliceDescriptor>
Finish() {
6405 const auto end = fbb_.EndTable(start_);
6406 auto o = flatbuffers::Offset<SliceDescriptor>(end);
6412 flatbuffers::FlatBufferBuilder &_fbb,
6418 return builder_.
Finish();
6422 flatbuffers::FlatBufferBuilder &_fbb,
6423 const std::vector<uint32_t> *begin =
nullptr,
6424 const std::vector<uint32_t> *size =
nullptr) {
6425 auto begin__ = begin ? _fbb.CreateVector<uint32_t>(*begin) : 0;
6426 auto size__ = size ? _fbb.CreateVector<uint32_t>(*size) : 0;
6433 struct StridedSliceLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6435 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6439 const armnnSerializer::LayerBase *
base()
const {
6440 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6442 const armnnSerializer::StridedSliceDescriptor *
descriptor()
const {
6443 return GetPointer<const armnnSerializer::StridedSliceDescriptor *>(
VT_DESCRIPTOR);
6445 bool Verify(flatbuffers::Verifier &verifier)
const {
6446 return VerifyTableStart(verifier) &&
6447 VerifyOffset(verifier,
VT_BASE) &&
6448 verifier.VerifyTable(base()) &&
6450 verifier.VerifyTable(descriptor()) &&
6451 verifier.EndTable();
6457 flatbuffers::FlatBufferBuilder &
fbb_;
6459 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6462 void add_descriptor(flatbuffers::Offset<armnnSerializer::StridedSliceDescriptor> descriptor) {
6467 start_ = fbb_.StartTable();
6470 flatbuffers::Offset<StridedSliceLayer>
Finish() {
6471 const auto end = fbb_.EndTable(start_);
6472 auto o = flatbuffers::Offset<StridedSliceLayer>(end);
6478 flatbuffers::FlatBufferBuilder &_fbb,
6479 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6480 flatbuffers::Offset<armnnSerializer::StridedSliceDescriptor> descriptor = 0) {
6484 return builder_.
Finish();
6487 struct StridedSliceDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6489 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6500 const flatbuffers::Vector<int32_t> *
begin()
const {
6501 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_BEGIN);
6503 const flatbuffers::Vector<int32_t> *
end()
const {
6504 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_END);
6506 const flatbuffers::Vector<int32_t> *
stride()
const {
6507 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_STRIDE);
6527 bool Verify(flatbuffers::Verifier &verifier)
const {
6528 return VerifyTableStart(verifier) &&
6529 VerifyOffset(verifier,
VT_BEGIN) &&
6530 verifier.VerifyVector(begin()) &&
6531 VerifyOffset(verifier,
VT_END) &&
6532 verifier.VerifyVector(end()) &&
6534 verifier.VerifyVector(stride()) &&
6536 VerifyField<int32_t>(verifier,
VT_ENDMASK) &&
6541 verifier.EndTable();
6547 flatbuffers::FlatBufferBuilder &
fbb_;
6578 start_ = fbb_.StartTable();
6581 flatbuffers::Offset<StridedSliceDescriptor>
Finish() {
6582 const auto end = fbb_.EndTable(start_);
6583 auto o = flatbuffers::Offset<StridedSliceDescriptor>(end);
6589 flatbuffers::FlatBufferBuilder &_fbb,
6593 int32_t beginMask = 0,
6594 int32_t endMask = 0,
6595 int32_t shrinkAxisMask = 0,
6596 int32_t ellipsisMask = 0,
6597 int32_t newAxisMask = 0,
6609 return builder_.
Finish();
6613 flatbuffers::FlatBufferBuilder &_fbb,
6614 const std::vector<int32_t> *begin =
nullptr,
6615 const std::vector<int32_t> *end =
nullptr,
6616 const std::vector<int32_t> *stride =
nullptr,
6617 int32_t beginMask = 0,
6618 int32_t endMask = 0,
6619 int32_t shrinkAxisMask = 0,
6620 int32_t ellipsisMask = 0,
6621 int32_t newAxisMask = 0,
6623 auto begin__ = begin ? _fbb.CreateVector<int32_t>(*begin) : 0;
6624 auto end__ = end ? _fbb.CreateVector<int32_t>(*end) : 0;
6625 auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0;
6639 struct ConcatLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6641 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6645 const armnnSerializer::LayerBase *
base()
const {
6646 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6649 return GetPointer<const armnnSerializer::OriginsDescriptor *>(
VT_DESCRIPTOR);
6651 bool Verify(flatbuffers::Verifier &verifier)
const {
6652 return VerifyTableStart(verifier) &&
6653 VerifyOffset(verifier,
VT_BASE) &&
6654 verifier.VerifyTable(base()) &&
6656 verifier.VerifyTable(descriptor()) &&
6657 verifier.EndTable();
6663 flatbuffers::FlatBufferBuilder &
fbb_;
6665 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6668 void add_descriptor(flatbuffers::Offset<armnnSerializer::OriginsDescriptor> descriptor) {
6673 start_ = fbb_.StartTable();
6677 const auto end = fbb_.EndTable(start_);
6678 auto o = flatbuffers::Offset<ConcatLayer>(end);
6684 flatbuffers::FlatBufferBuilder &_fbb,
6685 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6686 flatbuffers::Offset<armnnSerializer::OriginsDescriptor> descriptor = 0) {
6690 return builder_.
Finish();
6694 struct MergerLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6696 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6700 const armnnSerializer::LayerBase *
base()
const {
6701 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6704 return GetPointer<const armnnSerializer::OriginsDescriptor *>(
VT_DESCRIPTOR);
6706 bool Verify(flatbuffers::Verifier &verifier)
const {
6707 return VerifyTableStart(verifier) &&
6708 VerifyOffset(verifier,
VT_BASE) &&
6709 verifier.VerifyTable(base()) &&
6711 verifier.VerifyTable(descriptor()) &&
6712 verifier.EndTable();
6718 flatbuffers::FlatBufferBuilder &
fbb_;
6720 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6723 void add_descriptor(flatbuffers::Offset<armnnSerializer::OriginsDescriptor> descriptor) {
6728 start_ = fbb_.StartTable();
6732 const auto end = fbb_.EndTable(start_);
6733 auto o = flatbuffers::Offset<MergerLayer>(end);
6739 flatbuffers::FlatBufferBuilder &_fbb,
6740 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6741 flatbuffers::Offset<armnnSerializer::OriginsDescriptor> descriptor = 0) {
6745 return builder_.
Finish();
6748 struct UintVector FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6750 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6753 const flatbuffers::Vector<uint32_t> *
data()
const {
6754 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DATA);
6756 bool Verify(flatbuffers::Verifier &verifier)
const {
6757 return VerifyTableStart(verifier) &&
6758 VerifyOffset(verifier, VT_DATA) &&
6759 verifier.VerifyVector(data()) &&
6760 verifier.EndTable();
6766 flatbuffers::FlatBufferBuilder &
fbb_;
6769 fbb_.AddOffset(UintVector::VT_DATA, data);
6773 start_ = fbb_.StartTable();
6777 const auto end = fbb_.EndTable(start_);
6778 auto o = flatbuffers::Offset<UintVector>(end);
6784 flatbuffers::FlatBufferBuilder &_fbb,
6788 return builder_.
Finish();
6792 flatbuffers::FlatBufferBuilder &_fbb,
6793 const std::vector<uint32_t> *data =
nullptr) {
6794 auto data__ = data ? _fbb.CreateVector<uint32_t>(*data) : 0;
6800 struct OriginsDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6802 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6817 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>> *
viewOrigins()
const {
6818 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>> *>(VT_VIEWORIGINS);
6820 bool Verify(flatbuffers::Verifier &verifier)
const {
6821 return VerifyTableStart(verifier) &&
6825 VerifyOffset(verifier, VT_VIEWORIGINS) &&
6826 verifier.VerifyVector(viewOrigins()) &&
6827 verifier.VerifyVectorOfTables(viewOrigins()) &&
6828 verifier.EndTable();
6834 flatbuffers::FlatBufferBuilder &
fbb_;
6846 fbb_.AddOffset(OriginsDescriptor::VT_VIEWORIGINS, viewOrigins);
6850 start_ = fbb_.StartTable();
6853 flatbuffers::Offset<OriginsDescriptor>
Finish() {
6854 const auto end = fbb_.EndTable(start_);
6855 auto o = flatbuffers::Offset<OriginsDescriptor>(end);
6861 flatbuffers::FlatBufferBuilder &_fbb,
6862 uint32_t concatAxis = 0,
6863 uint32_t numViews = 0,
6864 uint32_t numDimensions = 0,
6865 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>>> viewOrigins = 0) {
6871 return builder_.
Finish();
6875 flatbuffers::FlatBufferBuilder &_fbb,
6876 uint32_t concatAxis = 0,
6877 uint32_t numViews = 0,
6878 uint32_t numDimensions = 0,
6879 const std::vector<flatbuffers::Offset<armnnSerializer::UintVector>> *viewOrigins =
nullptr) {
6880 auto viewOrigins__ = viewOrigins ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::UintVector>>(*viewOrigins) : 0;
6889 struct ViewsDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6891 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6895 const armnnSerializer::OriginsDescriptor *
origins()
const {
6896 return GetPointer<const armnnSerializer::OriginsDescriptor *>(
VT_ORIGINS);
6898 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>> *
viewSizes()
const {
6899 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>> *>(VT_VIEWSIZES);
6901 bool Verify(flatbuffers::Verifier &verifier)
const {
6902 return VerifyTableStart(verifier) &&
6904 verifier.VerifyTable(origins()) &&
6905 VerifyOffset(verifier, VT_VIEWSIZES) &&
6906 verifier.VerifyVector(viewSizes()) &&
6907 verifier.VerifyVectorOfTables(viewSizes()) &&
6908 verifier.EndTable();
6914 flatbuffers::FlatBufferBuilder &
fbb_;
6916 void add_origins(flatbuffers::Offset<armnnSerializer::OriginsDescriptor> origins) {
6920 fbb_.AddOffset(ViewsDescriptor::VT_VIEWSIZES, viewSizes);
6924 start_ = fbb_.StartTable();
6927 flatbuffers::Offset<ViewsDescriptor>
Finish() {
6928 const auto end = fbb_.EndTable(start_);
6929 auto o = flatbuffers::Offset<ViewsDescriptor>(end);
6935 flatbuffers::FlatBufferBuilder &_fbb,
6936 flatbuffers::Offset<armnnSerializer::OriginsDescriptor> origins = 0,
6937 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>>> viewSizes = 0) {
6941 return builder_.
Finish();
6945 flatbuffers::FlatBufferBuilder &_fbb,
6946 flatbuffers::Offset<armnnSerializer::OriginsDescriptor> origins = 0,
6947 const std::vector<flatbuffers::Offset<armnnSerializer::UintVector>> *viewSizes =
nullptr) {
6948 auto viewSizes__ = viewSizes ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::UintVector>>(*viewSizes) : 0;
6955 struct SplitterLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6957 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6961 const armnnSerializer::LayerBase *
base()
const {
6962 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6965 return GetPointer<const armnnSerializer::ViewsDescriptor *>(
VT_DESCRIPTOR);
6967 bool Verify(flatbuffers::Verifier &verifier)
const {
6968 return VerifyTableStart(verifier) &&
6969 VerifyOffset(verifier,
VT_BASE) &&
6970 verifier.VerifyTable(base()) &&
6972 verifier.VerifyTable(descriptor()) &&
6973 verifier.EndTable();
6979 flatbuffers::FlatBufferBuilder &
fbb_;
6981 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6984 void add_descriptor(flatbuffers::Offset<armnnSerializer::ViewsDescriptor> descriptor) {
6989 start_ = fbb_.StartTable();
6992 flatbuffers::Offset<SplitterLayer>
Finish() {
6993 const auto end = fbb_.EndTable(start_);
6994 auto o = flatbuffers::Offset<SplitterLayer>(end);
7000 flatbuffers::FlatBufferBuilder &_fbb,
7001 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7002 flatbuffers::Offset<armnnSerializer::ViewsDescriptor> descriptor = 0) {
7006 return builder_.
Finish();
7009 struct DetectionPostProcessLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7011 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7016 const armnnSerializer::LayerBase *
base()
const {
7017 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
7019 const armnnSerializer::DetectionPostProcessDescriptor *
descriptor()
const {
7020 return GetPointer<const armnnSerializer::DetectionPostProcessDescriptor *>(
VT_DESCRIPTOR);
7022 const armnnSerializer::ConstTensor *
anchors()
const {
7023 return GetPointer<const armnnSerializer::ConstTensor *>(VT_ANCHORS);
7025 bool Verify(flatbuffers::Verifier &verifier)
const {
7026 return VerifyTableStart(verifier) &&
7027 VerifyOffset(verifier,
VT_BASE) &&
7028 verifier.VerifyTable(base()) &&
7030 verifier.VerifyTable(descriptor()) &&
7031 VerifyOffset(verifier, VT_ANCHORS) &&
7032 verifier.VerifyTable(
anchors()) &&
7033 verifier.EndTable();
7038 typedef DetectionPostProcessLayer
Table;
7039 flatbuffers::FlatBufferBuilder &
fbb_;
7041 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
7044 void add_descriptor(flatbuffers::Offset<armnnSerializer::DetectionPostProcessDescriptor> descriptor) {
7048 fbb_.AddOffset(DetectionPostProcessLayer::VT_ANCHORS, anchors);
7052 start_ = fbb_.StartTable();
7055 flatbuffers::Offset<DetectionPostProcessLayer>
Finish() {
7056 const auto end = fbb_.EndTable(start_);
7057 auto o = flatbuffers::Offset<DetectionPostProcessLayer>(end);
7063 flatbuffers::FlatBufferBuilder &_fbb,
7064 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7065 flatbuffers::Offset<armnnSerializer::DetectionPostProcessDescriptor> descriptor = 0,
7066 flatbuffers::Offset<armnnSerializer::ConstTensor>
anchors = 0) {
7071 return builder_.
Finish();
7074 struct DetectionPostProcessDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7076 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7111 return GetField<float>(
VT_SCALEX, 0.0f);
7114 return GetField<float>(
VT_SCALEY, 0.0f);
7117 return GetField<float>(
VT_SCALEW, 0.0f);
7120 return GetField<float>(VT_SCALEH, 0.0f);
7122 bool Verify(flatbuffers::Verifier &verifier)
const {
7123 return VerifyTableStart(verifier) &&
7131 VerifyField<float>(verifier,
VT_SCALEX) &&
7132 VerifyField<float>(verifier,
VT_SCALEY) &&
7133 VerifyField<float>(verifier,
VT_SCALEW) &&
7134 VerifyField<float>(verifier, VT_SCALEH) &&
7135 verifier.EndTable();
7140 typedef DetectionPostProcessDescriptor
Table;
7141 flatbuffers::FlatBufferBuilder &
fbb_;
7174 fbb_.AddElement<
float>(DetectionPostProcessDescriptor::VT_SCALEH, scaleH, 0.0f);
7178 start_ = fbb_.StartTable();
7181 flatbuffers::Offset<DetectionPostProcessDescriptor>
Finish() {
7182 const auto end = fbb_.EndTable(start_);
7183 auto o = flatbuffers::Offset<DetectionPostProcessDescriptor>(end);
7189 flatbuffers::FlatBufferBuilder &_fbb,
7190 uint32_t maxDetections = 0,
7191 uint32_t maxClassesPerDetection = 0,
7192 uint32_t detectionsPerClass = 0,
7193 float nmsScoreThreshold = 0.0f,
7194 float nmsIouThreshold = 0.0f,
7195 uint32_t numClasses = 0,
7196 bool useRegularNms =
false,
7197 float scaleX = 0.0f,
7198 float scaleY = 0.0f,
7199 float scaleW = 0.0f,
7200 float scaleH = 0.0f) {
7213 return builder_.
Finish();
7216 struct LstmInputParams FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7218 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7239 VT_OUTPUTLAYERNORMWEIGHTS = 44
7263 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_CELLBIAS);
7302 return GetPointer<const armnnSerializer::ConstTensor *>(VT_OUTPUTLAYERNORMWEIGHTS);
7304 bool Verify(flatbuffers::Verifier &verifier)
const {
7305 return VerifyTableStart(verifier) &&
7307 verifier.VerifyTable(inputToForgetWeights()) &&
7309 verifier.VerifyTable(inputToCellWeights()) &&
7311 verifier.VerifyTable(inputToOutputWeights()) &&
7313 verifier.VerifyTable(recurrentToForgetWeights()) &&
7315 verifier.VerifyTable(recurrentToCellWeights()) &&
7317 verifier.VerifyTable(recurrentToOutputWeights()) &&
7319 verifier.VerifyTable(forgetGateBias()) &&
7321 verifier.VerifyTable(cellBias()) &&
7323 verifier.VerifyTable(outputGateBias()) &&
7325 verifier.VerifyTable(inputToInputWeights()) &&
7327 verifier.VerifyTable(recurrentToInputWeights()) &&
7329 verifier.VerifyTable(cellToInputWeights()) &&
7331 verifier.VerifyTable(inputGateBias()) &&
7333 verifier.VerifyTable(projectionWeights()) &&
7335 verifier.VerifyTable(projectionBias()) &&
7337 verifier.VerifyTable(cellToForgetWeights()) &&
7339 verifier.VerifyTable(cellToOutputWeights()) &&
7341 verifier.VerifyTable(inputLayerNormWeights()) &&
7343 verifier.VerifyTable(forgetLayerNormWeights()) &&
7345 verifier.VerifyTable(cellLayerNormWeights()) &&
7346 VerifyOffset(verifier, VT_OUTPUTLAYERNORMWEIGHTS) &&
7347 verifier.VerifyTable(outputLayerNormWeights()) &&
7348 verifier.EndTable();
7354 flatbuffers::FlatBufferBuilder &
fbb_;
7377 void add_cellBias(flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias) {
7417 fbb_.AddOffset(LstmInputParams::VT_OUTPUTLAYERNORMWEIGHTS, outputLayerNormWeights);
7421 start_ = fbb_.StartTable();
7424 flatbuffers::Offset<LstmInputParams>
Finish() {
7425 const auto end = fbb_.EndTable(start_);
7426 auto o = flatbuffers::Offset<LstmInputParams>(end);
7432 flatbuffers::FlatBufferBuilder &_fbb,
7433 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToForgetWeights = 0,
7434 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToCellWeights = 0,
7435 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToOutputWeights = 0,
7436 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToForgetWeights = 0,
7437 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToCellWeights = 0,
7438 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToOutputWeights = 0,
7439 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetGateBias = 0,
7440 flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias = 0,
7441 flatbuffers::Offset<armnnSerializer::ConstTensor> outputGateBias = 0,
7442 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToInputWeights = 0,
7443 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToInputWeights = 0,
7444 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToInputWeights = 0,
7445 flatbuffers::Offset<armnnSerializer::ConstTensor> inputGateBias = 0,
7446 flatbuffers::Offset<armnnSerializer::ConstTensor> projectionWeights = 0,
7447 flatbuffers::Offset<armnnSerializer::ConstTensor> projectionBias = 0,
7448 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToForgetWeights = 0,
7449 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToOutputWeights = 0,
7450 flatbuffers::Offset<armnnSerializer::ConstTensor> inputLayerNormWeights = 0,
7451 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetLayerNormWeights = 0,
7452 flatbuffers::Offset<armnnSerializer::ConstTensor> cellLayerNormWeights = 0,
7453 flatbuffers::Offset<armnnSerializer::ConstTensor> outputLayerNormWeights = 0) {
7476 return builder_.
Finish();
7479 struct LstmDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7481 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7511 bool Verify(flatbuffers::Verifier &verifier)
const {
7512 return VerifyTableStart(verifier) &&
7520 verifier.EndTable();
7526 flatbuffers::FlatBufferBuilder &
fbb_;
7551 start_ = fbb_.StartTable();
7554 flatbuffers::Offset<LstmDescriptor>
Finish() {
7555 const auto end = fbb_.EndTable(start_);
7556 auto o = flatbuffers::Offset<LstmDescriptor>(end);
7562 flatbuffers::FlatBufferBuilder &_fbb,
7563 uint32_t activationFunc = 0,
7564 float clippingThresCell = 0.0f,
7565 float clippingThresProj = 0.0f,
7566 bool cifgEnabled =
true,
7567 bool peepholeEnabled =
false,
7568 bool projectionEnabled =
false,
7569 bool layerNormEnabled =
false) {
7578 return builder_.
Finish();
7581 struct LstmLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7583 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7588 const armnnSerializer::LayerBase *
base()
const {
7589 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
7592 return GetPointer<const armnnSerializer::LstmDescriptor *>(
VT_DESCRIPTOR);
7595 return GetPointer<const armnnSerializer::LstmInputParams *>(VT_INPUTPARAMS);
7597 bool Verify(flatbuffers::Verifier &verifier)
const {
7598 return VerifyTableStart(verifier) &&
7599 VerifyOffset(verifier,
VT_BASE) &&
7600 verifier.VerifyTable(base()) &&
7602 verifier.VerifyTable(descriptor()) &&
7603 VerifyOffset(verifier, VT_INPUTPARAMS) &&
7604 verifier.VerifyTable(inputParams()) &&
7605 verifier.EndTable();
7611 flatbuffers::FlatBufferBuilder &
fbb_;
7613 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
7616 void add_descriptor(flatbuffers::Offset<armnnSerializer::LstmDescriptor> descriptor) {
7620 fbb_.AddOffset(LstmLayer::VT_INPUTPARAMS, inputParams);
7624 start_ = fbb_.StartTable();
7628 const auto end = fbb_.EndTable(start_);
7629 auto o = flatbuffers::Offset<LstmLayer>(end);
7635 flatbuffers::FlatBufferBuilder &_fbb,
7636 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7637 flatbuffers::Offset<armnnSerializer::LstmDescriptor> descriptor = 0,
7638 flatbuffers::Offset<armnnSerializer::LstmInputParams> inputParams = 0) {
7643 return builder_.
Finish();
7646 struct QLstmInputParams FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7648 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7669 VT_OUTPUTLAYERNORMWEIGHTS = 44
7693 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_CELLBIAS);
7732 return GetPointer<const armnnSerializer::ConstTensor *>(VT_OUTPUTLAYERNORMWEIGHTS);
7734 bool Verify(flatbuffers::Verifier &verifier)
const {
7735 return VerifyTableStart(verifier) &&
7737 verifier.VerifyTable(inputToForgetWeights()) &&
7739 verifier.VerifyTable(inputToCellWeights()) &&
7741 verifier.VerifyTable(inputToOutputWeights()) &&
7743 verifier.VerifyTable(recurrentToForgetWeights()) &&
7745 verifier.VerifyTable(recurrentToCellWeights()) &&
7747 verifier.VerifyTable(recurrentToOutputWeights()) &&
7749 verifier.VerifyTable(forgetGateBias()) &&
7751 verifier.VerifyTable(cellBias()) &&
7753 verifier.VerifyTable(outputGateBias()) &&
7755 verifier.VerifyTable(inputToInputWeights()) &&
7757 verifier.VerifyTable(recurrentToInputWeights()) &&
7759 verifier.VerifyTable(inputGateBias()) &&
7761 verifier.VerifyTable(projectionWeights()) &&
7763 verifier.VerifyTable(projectionBias()) &&
7765 verifier.VerifyTable(cellToInputWeights()) &&
7767 verifier.VerifyTable(cellToForgetWeights()) &&
7769 verifier.VerifyTable(cellToOutputWeights()) &&
7771 verifier.VerifyTable(inputLayerNormWeights()) &&
7773 verifier.VerifyTable(forgetLayerNormWeights()) &&
7775 verifier.VerifyTable(cellLayerNormWeights()) &&
7776 VerifyOffset(verifier, VT_OUTPUTLAYERNORMWEIGHTS) &&
7777 verifier.VerifyTable(outputLayerNormWeights()) &&
7778 verifier.EndTable();
7784 flatbuffers::FlatBufferBuilder &
fbb_;
7807 void add_cellBias(flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias) {
7847 fbb_.AddOffset(QLstmInputParams::VT_OUTPUTLAYERNORMWEIGHTS, outputLayerNormWeights);
7851 start_ = fbb_.StartTable();
7854 flatbuffers::Offset<QLstmInputParams>
Finish() {
7855 const auto end = fbb_.EndTable(start_);
7856 auto o = flatbuffers::Offset<QLstmInputParams>(end);
7862 flatbuffers::FlatBufferBuilder &_fbb,
7863 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToForgetWeights = 0,
7864 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToCellWeights = 0,
7865 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToOutputWeights = 0,
7866 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToForgetWeights = 0,
7867 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToCellWeights = 0,
7868 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToOutputWeights = 0,
7869 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetGateBias = 0,
7870 flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias = 0,
7871 flatbuffers::Offset<armnnSerializer::ConstTensor> outputGateBias = 0,
7872 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToInputWeights = 0,
7873 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToInputWeights = 0,
7874 flatbuffers::Offset<armnnSerializer::ConstTensor> inputGateBias = 0,
7875 flatbuffers::Offset<armnnSerializer::ConstTensor> projectionWeights = 0,
7876 flatbuffers::Offset<armnnSerializer::ConstTensor> projectionBias = 0,
7877 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToInputWeights = 0,
7878 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToForgetWeights = 0,
7879 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToOutputWeights = 0,
7880 flatbuffers::Offset<armnnSerializer::ConstTensor> inputLayerNormWeights = 0,
7881 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetLayerNormWeights = 0,
7882 flatbuffers::Offset<armnnSerializer::ConstTensor> cellLayerNormWeights = 0,
7883 flatbuffers::Offset<armnnSerializer::ConstTensor> outputLayerNormWeights = 0) {
7906 return builder_.
Finish();
7909 struct QLstmDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7911 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7923 VT_HIDDENSTATESCALE = 26
7959 return GetField<float>(VT_HIDDENSTATESCALE, 0.0f);
7961 bool Verify(flatbuffers::Verifier &verifier)
const {
7962 return VerifyTableStart(verifier) &&
7974 VerifyField<float>(verifier, VT_HIDDENSTATESCALE) &&
7975 verifier.EndTable();
7981 flatbuffers::FlatBufferBuilder &
fbb_;
8017 fbb_.AddElement<
float>(QLstmDescriptor::VT_HIDDENSTATESCALE, hiddenStateScale, 0.0f);
8021 start_ = fbb_.StartTable();
8024 flatbuffers::Offset<QLstmDescriptor>
Finish() {
8025 const auto end = fbb_.EndTable(start_);
8026 auto o = flatbuffers::Offset<QLstmDescriptor>(end);
8032 flatbuffers::FlatBufferBuilder &_fbb,
8033 bool cifgEnabled =
true,
8034 bool peepholeEnabled =
false,
8035 bool projectionEnabled =
false,
8036 bool layerNormEnabled =
false,
8037 float cellClip = 0.0f,
8038 float projectionClip = 0.0f,
8039 float inputIntermediateScale = 0.0f,
8040 float forgetIntermediateScale = 0.0f,
8041 float cellIntermediateScale = 0.0f,
8042 float outputIntermediateScale = 0.0f,
8043 int32_t hiddenStateZeroPoint = 0,
8044 float hiddenStateScale = 0.0f) {
8058 return builder_.
Finish();
8061 struct QLstmLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8063 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8068 const armnnSerializer::LayerBase *
base()
const {
8069 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8072 return GetPointer<const armnnSerializer::QLstmDescriptor *>(
VT_DESCRIPTOR);
8075 return GetPointer<const armnnSerializer::QLstmInputParams *>(VT_INPUTPARAMS);
8077 bool Verify(flatbuffers::Verifier &verifier)
const {
8078 return VerifyTableStart(verifier) &&
8079 VerifyOffset(verifier,
VT_BASE) &&
8080 verifier.VerifyTable(base()) &&
8082 verifier.VerifyTable(descriptor()) &&
8083 VerifyOffset(verifier, VT_INPUTPARAMS) &&
8084 verifier.VerifyTable(inputParams()) &&
8085 verifier.EndTable();
8091 flatbuffers::FlatBufferBuilder &
fbb_;
8093 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8096 void add_descriptor(flatbuffers::Offset<armnnSerializer::QLstmDescriptor> descriptor) {
8099 void add_inputParams(flatbuffers::Offset<armnnSerializer::QLstmInputParams> inputParams) {
8100 fbb_.AddOffset(QLstmLayer::VT_INPUTPARAMS, inputParams);
8104 start_ = fbb_.StartTable();
8108 const auto end = fbb_.EndTable(start_);
8109 auto o = flatbuffers::Offset<QLstmLayer>(end);
8115 flatbuffers::FlatBufferBuilder &_fbb,
8116 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
8117 flatbuffers::Offset<armnnSerializer::QLstmDescriptor> descriptor = 0,
8118 flatbuffers::Offset<armnnSerializer::QLstmInputParams> inputParams = 0) {
8123 return builder_.
Finish();
8126 struct QuantizedLstmInputParams FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8128 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8173 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_CELLBIAS);
8178 bool Verify(flatbuffers::Verifier &verifier)
const {
8179 return VerifyTableStart(verifier) &&
8181 verifier.VerifyTable(inputToInputWeights()) &&
8183 verifier.VerifyTable(inputToForgetWeights()) &&
8185 verifier.VerifyTable(inputToCellWeights()) &&
8187 verifier.VerifyTable(inputToOutputWeights()) &&
8189 verifier.VerifyTable(recurrentToInputWeights()) &&
8191 verifier.VerifyTable(recurrentToForgetWeights()) &&
8193 verifier.VerifyTable(recurrentToCellWeights()) &&
8195 verifier.VerifyTable(recurrentToOutputWeights()) &&
8197 verifier.VerifyTable(inputGateBias()) &&
8199 verifier.VerifyTable(forgetGateBias()) &&
8201 verifier.VerifyTable(cellBias()) &&
8203 verifier.VerifyTable(outputGateBias()) &&
8204 verifier.EndTable();
8210 flatbuffers::FlatBufferBuilder &
fbb_;
8242 void add_cellBias(flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias) {
8250 start_ = fbb_.StartTable();
8253 flatbuffers::Offset<QuantizedLstmInputParams>
Finish() {
8254 const auto end = fbb_.EndTable(start_);
8255 auto o = flatbuffers::Offset<QuantizedLstmInputParams>(end);
8261 flatbuffers::FlatBufferBuilder &_fbb,
8262 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToInputWeights = 0,
8263 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToForgetWeights = 0,
8264 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToCellWeights = 0,
8265 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToOutputWeights = 0,
8266 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToInputWeights = 0,
8267 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToForgetWeights = 0,
8268 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToCellWeights = 0,
8269 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToOutputWeights = 0,
8270 flatbuffers::Offset<armnnSerializer::ConstTensor> inputGateBias = 0,
8271 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetGateBias = 0,
8272 flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias = 0,
8273 flatbuffers::Offset<armnnSerializer::ConstTensor> outputGateBias = 0) {
8287 return builder_.
Finish();
8290 struct QuantizedLstmLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8292 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8296 const armnnSerializer::LayerBase *
base()
const {
8297 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8299 const armnnSerializer::QuantizedLstmInputParams *
inputParams()
const {
8300 return GetPointer<const armnnSerializer::QuantizedLstmInputParams *>(VT_INPUTPARAMS);
8302 bool Verify(flatbuffers::Verifier &verifier)
const {
8303 return VerifyTableStart(verifier) &&
8304 VerifyOffset(verifier,
VT_BASE) &&
8305 verifier.VerifyTable(base()) &&
8306 VerifyOffset(verifier, VT_INPUTPARAMS) &&
8307 verifier.VerifyTable(inputParams()) &&
8308 verifier.EndTable();
8314 flatbuffers::FlatBufferBuilder &
fbb_;
8316 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8319 void add_inputParams(flatbuffers::Offset<armnnSerializer::QuantizedLstmInputParams> inputParams) {
8320 fbb_.AddOffset(QuantizedLstmLayer::VT_INPUTPARAMS, inputParams);
8324 start_ = fbb_.StartTable();
8327 flatbuffers::Offset<QuantizedLstmLayer>
Finish() {
8328 const auto end = fbb_.EndTable(start_);
8329 auto o = flatbuffers::Offset<QuantizedLstmLayer>(end);
8335 flatbuffers::FlatBufferBuilder &_fbb,
8336 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
8337 flatbuffers::Offset<armnnSerializer::QuantizedLstmInputParams> inputParams = 0) {
8341 return builder_.
Finish();
8344 struct DequantizeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8346 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8349 const armnnSerializer::LayerBase *
base()
const {
8350 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8352 bool Verify(flatbuffers::Verifier &verifier)
const {
8353 return VerifyTableStart(verifier) &&
8354 VerifyOffset(verifier,
VT_BASE) &&
8355 verifier.VerifyTable(base()) &&
8356 verifier.EndTable();
8362 flatbuffers::FlatBufferBuilder &
fbb_;
8364 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8369 start_ = fbb_.StartTable();
8372 flatbuffers::Offset<DequantizeLayer>
Finish() {
8373 const auto end = fbb_.EndTable(start_);
8374 auto o = flatbuffers::Offset<DequantizeLayer>(end);
8380 flatbuffers::FlatBufferBuilder &_fbb,
8381 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
8384 return builder_.
Finish();
8387 struct MergeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8389 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8392 const armnnSerializer::LayerBase *
base()
const {
8393 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8395 bool Verify(flatbuffers::Verifier &verifier)
const {
8396 return VerifyTableStart(verifier) &&
8397 VerifyOffset(verifier,
VT_BASE) &&
8398 verifier.VerifyTable(base()) &&
8399 verifier.EndTable();
8405 flatbuffers::FlatBufferBuilder &
fbb_;
8407 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8412 start_ = fbb_.StartTable();
8416 const auto end = fbb_.EndTable(start_);
8417 auto o = flatbuffers::Offset<MergeLayer>(end);
8423 flatbuffers::FlatBufferBuilder &_fbb,
8424 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
8427 return builder_.
Finish();
8430 struct SwitchLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8432 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8435 const armnnSerializer::LayerBase *
base()
const {
8436 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8438 bool Verify(flatbuffers::Verifier &verifier)
const {
8439 return VerifyTableStart(verifier) &&
8440 VerifyOffset(verifier,
VT_BASE) &&
8441 verifier.VerifyTable(base()) &&
8442 verifier.EndTable();
8448 flatbuffers::FlatBufferBuilder &
fbb_;
8450 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8455 start_ = fbb_.StartTable();
8459 const auto end = fbb_.EndTable(start_);
8460 auto o = flatbuffers::Offset<SwitchLayer>(end);
8466 flatbuffers::FlatBufferBuilder &_fbb,
8467 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
8470 return builder_.
Finish();
8473 struct PreluLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8475 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8478 const armnnSerializer::LayerBase *
base()
const {
8479 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8481 bool Verify(flatbuffers::Verifier &verifier)
const {
8482 return VerifyTableStart(verifier) &&
8483 VerifyOffset(verifier,
VT_BASE) &&
8484 verifier.VerifyTable(base()) &&
8485 verifier.EndTable();
8491 flatbuffers::FlatBufferBuilder &
fbb_;
8493 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8498 start_ = fbb_.StartTable();
8502 const auto end = fbb_.EndTable(start_);
8503 auto o = flatbuffers::Offset<PreluLayer>(end);
8509 flatbuffers::FlatBufferBuilder &_fbb,
8510 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
8513 return builder_.
Finish();
8516 struct TransposeConvolution2dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8518 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8524 const armnnSerializer::LayerBase *
base()
const {
8525 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8527 const armnnSerializer::TransposeConvolution2dDescriptor *
descriptor()
const {
8528 return GetPointer<const armnnSerializer::TransposeConvolution2dDescriptor *>(
VT_DESCRIPTOR);
8530 const armnnSerializer::ConstTensor *
weights()
const {
8531 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_WEIGHTS);
8533 const armnnSerializer::ConstTensor *
biases()
const {
8534 return GetPointer<const armnnSerializer::ConstTensor *>(VT_BIASES);
8536 bool Verify(flatbuffers::Verifier &verifier)
const {
8537 return VerifyTableStart(verifier) &&
8538 VerifyOffset(verifier,
VT_BASE) &&
8539 verifier.VerifyTable(base()) &&
8541 verifier.VerifyTable(descriptor()) &&
8543 verifier.VerifyTable(weights()) &&
8544 VerifyOffset(verifier, VT_BIASES) &&
8545 verifier.VerifyTable(biases()) &&
8546 verifier.EndTable();
8551 typedef TransposeConvolution2dLayer
Table;
8552 flatbuffers::FlatBufferBuilder &
fbb_;
8554 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8557 void add_descriptor(flatbuffers::Offset<armnnSerializer::TransposeConvolution2dDescriptor> descriptor) {
8560 void add_weights(flatbuffers::Offset<armnnSerializer::ConstTensor> weights) {
8563 void add_biases(flatbuffers::Offset<armnnSerializer::ConstTensor> biases) {
8564 fbb_.AddOffset(TransposeConvolution2dLayer::VT_BIASES, biases);
8568 start_ = fbb_.StartTable();
8571 flatbuffers::Offset<TransposeConvolution2dLayer>
Finish() {
8572 const auto end = fbb_.EndTable(start_);
8573 auto o = flatbuffers::Offset<TransposeConvolution2dLayer>(end);
8579 flatbuffers::FlatBufferBuilder &_fbb,
8580 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
8581 flatbuffers::Offset<armnnSerializer::TransposeConvolution2dDescriptor> descriptor = 0,
8582 flatbuffers::Offset<armnnSerializer::ConstTensor> weights = 0,
8583 flatbuffers::Offset<armnnSerializer::ConstTensor> biases = 0) {
8589 return builder_.
Finish();
8592 struct TransposeConvolution2dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8594 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8611 return GetField<uint32_t>(
VT_PADTOP, 0);
8628 bool Verify(flatbuffers::Verifier &verifier)
const {
8629 return VerifyTableStart(verifier) &&
8630 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
8632 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
8634 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
8635 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
8638 verifier.EndTable();
8643 typedef TransposeConvolution2dDescriptor
Table;
8644 flatbuffers::FlatBufferBuilder &
fbb_;
8672 start_ = fbb_.StartTable();
8675 flatbuffers::Offset<TransposeConvolution2dDescriptor>
Finish() {
8676 const auto end = fbb_.EndTable(start_);
8677 auto o = flatbuffers::Offset<TransposeConvolution2dDescriptor>(end);
8683 flatbuffers::FlatBufferBuilder &_fbb,
8684 uint32_t padLeft = 0,
8685 uint32_t padRight = 0,
8686 uint32_t padTop = 0,
8687 uint32_t padBottom = 0,
8688 uint32_t strideX = 0,
8689 uint32_t strideY = 0,
8690 bool biasEnabled =
false,
8701 return builder_.
Finish();
8704 struct TransposeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8706 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8710 const armnnSerializer::LayerBase *
base()
const {
8711 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8714 return GetPointer<const armnnSerializer::TransposeDescriptor *>(
VT_DESCRIPTOR);
8716 bool Verify(flatbuffers::Verifier &verifier)
const {
8717 return VerifyTableStart(verifier) &&
8718 VerifyOffset(verifier,
VT_BASE) &&
8719 verifier.VerifyTable(base()) &&
8721 verifier.VerifyTable(descriptor()) &&
8722 verifier.EndTable();
8728 flatbuffers::FlatBufferBuilder &
fbb_;
8730 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8733 void add_descriptor(flatbuffers::Offset<armnnSerializer::TransposeDescriptor> descriptor) {
8738 start_ = fbb_.StartTable();
8741 flatbuffers::Offset<TransposeLayer>
Finish() {
8742 const auto end = fbb_.EndTable(start_);
8743 auto o = flatbuffers::Offset<TransposeLayer>(end);
8749 flatbuffers::FlatBufferBuilder &_fbb,
8750 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
8751 flatbuffers::Offset<armnnSerializer::TransposeDescriptor> descriptor = 0) {
8755 return builder_.
Finish();
8758 struct TransposeDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8760 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8764 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DIMMAPPINGS);
8766 bool Verify(flatbuffers::Verifier &verifier)
const {
8767 return VerifyTableStart(verifier) &&
8768 VerifyOffset(verifier, VT_DIMMAPPINGS) &&
8769 verifier.VerifyVector(dimMappings()) &&
8770 verifier.EndTable();
8776 flatbuffers::FlatBufferBuilder &
fbb_;
8779 fbb_.AddOffset(TransposeDescriptor::VT_DIMMAPPINGS, dimMappings);
8783 start_ = fbb_.StartTable();
8786 flatbuffers::Offset<TransposeDescriptor>
Finish() {
8787 const auto end = fbb_.EndTable(start_);
8788 auto o = flatbuffers::Offset<TransposeDescriptor>(end);
8794 flatbuffers::FlatBufferBuilder &_fbb,
8798 return builder_.
Finish();
8802 flatbuffers::FlatBufferBuilder &_fbb,
8803 const std::vector<uint32_t> *dimMappings =
nullptr) {
8804 auto dimMappings__ = dimMappings ? _fbb.CreateVector<uint32_t>(*dimMappings) : 0;
8810 struct ResizeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8812 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8816 const armnnSerializer::LayerBase *
base()
const {
8817 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8820 return GetPointer<const armnnSerializer::ResizeDescriptor *>(
VT_DESCRIPTOR);
8822 bool Verify(flatbuffers::Verifier &verifier)
const {
8823 return VerifyTableStart(verifier) &&
8824 VerifyOffset(verifier,
VT_BASE) &&
8825 verifier.VerifyTable(base()) &&
8827 verifier.VerifyTable(descriptor()) &&
8828 verifier.EndTable();
8834 flatbuffers::FlatBufferBuilder &
fbb_;
8836 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8839 void add_descriptor(flatbuffers::Offset<armnnSerializer::ResizeDescriptor> descriptor) {
8844 start_ = fbb_.StartTable();
8848 const auto end = fbb_.EndTable(start_);
8849 auto o = flatbuffers::Offset<ResizeLayer>(end);
8855 flatbuffers::FlatBufferBuilder &_fbb,
8856 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
8857 flatbuffers::Offset<armnnSerializer::ResizeDescriptor> descriptor = 0) {
8861 return builder_.
Finish();
8864 struct ResizeDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8866 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8872 VT_HALFPIXELCENTERS = 14
8890 return GetField<uint8_t>(VT_HALFPIXELCENTERS, 0) != 0;
8892 bool Verify(flatbuffers::Verifier &verifier)
const {
8893 return VerifyTableStart(verifier) &&
8896 VerifyField<int8_t>(verifier,
VT_METHOD) &&
8899 VerifyField<uint8_t>(verifier, VT_HALFPIXELCENTERS) &&
8900 verifier.EndTable();
8906 flatbuffers::FlatBufferBuilder &
fbb_;
8924 fbb_.AddElement<uint8_t>(ResizeDescriptor::VT_HALFPIXELCENTERS,
static_cast<uint8_t
>(halfPixelCenters), 0);
8928 start_ = fbb_.StartTable();
8931 flatbuffers::Offset<ResizeDescriptor>
Finish() {
8932 const auto end = fbb_.EndTable(start_);
8933 auto o = flatbuffers::Offset<ResizeDescriptor>(end);
8939 flatbuffers::FlatBufferBuilder &_fbb,
8940 uint32_t targetHeight = 0,
8941 uint32_t targetWidth = 0,
8944 bool alignCorners =
false,
8945 bool halfPixelCenters =
false) {
8953 return builder_.
Finish();
8956 struct StackLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8958 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8962 const armnnSerializer::LayerBase *
base()
const {
8963 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8966 return GetPointer<const armnnSerializer::StackDescriptor *>(
VT_DESCRIPTOR);
8968 bool Verify(flatbuffers::Verifier &verifier)
const {
8969 return VerifyTableStart(verifier) &&
8970 VerifyOffset(verifier,
VT_BASE) &&
8971 verifier.VerifyTable(base()) &&
8973 verifier.VerifyTable(descriptor()) &&
8974 verifier.EndTable();
8980 flatbuffers::FlatBufferBuilder &
fbb_;
8982 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8985 void add_descriptor(flatbuffers::Offset<armnnSerializer::StackDescriptor> descriptor) {
8990 start_ = fbb_.StartTable();
8994 const auto end = fbb_.EndTable(start_);
8995 auto o = flatbuffers::Offset<StackLayer>(end);
9001 flatbuffers::FlatBufferBuilder &_fbb,
9002 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9003 flatbuffers::Offset<armnnSerializer::StackDescriptor> descriptor = 0) {
9007 return builder_.
Finish();
9010 struct StackDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9012 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9018 return GetField<uint32_t>(
VT_AXIS, 0);
9024 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_INPUTSHAPE);
9026 bool Verify(flatbuffers::Verifier &verifier)
const {
9027 return VerifyTableStart(verifier) &&
9028 VerifyField<uint32_t>(verifier,
VT_AXIS) &&
9030 VerifyOffset(verifier, VT_INPUTSHAPE) &&
9031 verifier.VerifyVector(inputShape()) &&
9032 verifier.EndTable();
9038 flatbuffers::FlatBufferBuilder &
fbb_;
9047 fbb_.AddOffset(StackDescriptor::VT_INPUTSHAPE, inputShape);
9051 start_ = fbb_.StartTable();
9054 flatbuffers::Offset<StackDescriptor>
Finish() {
9055 const auto end = fbb_.EndTable(start_);
9056 auto o = flatbuffers::Offset<StackDescriptor>(end);
9062 flatbuffers::FlatBufferBuilder &_fbb,
9064 uint32_t numInputs = 0,
9070 return builder_.
Finish();
9074 flatbuffers::FlatBufferBuilder &_fbb,
9076 uint32_t numInputs = 0,
9077 const std::vector<uint32_t> *inputShape =
nullptr) {
9078 auto inputShape__ = inputShape ? _fbb.CreateVector<uint32_t>(*inputShape) : 0;
9086 struct StandInDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9088 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9096 return GetField<uint32_t>(VT_NUMOUTPUTS, 0);
9098 bool Verify(flatbuffers::Verifier &verifier)
const {
9099 return VerifyTableStart(verifier) &&
9101 VerifyField<uint32_t>(verifier, VT_NUMOUTPUTS) &&
9102 verifier.EndTable();
9108 flatbuffers::FlatBufferBuilder &
fbb_;
9114 fbb_.AddElement<uint32_t>(StandInDescriptor::VT_NUMOUTPUTS, numOutputs, 0);
9118 start_ = fbb_.StartTable();
9121 flatbuffers::Offset<StandInDescriptor>
Finish() {
9122 const auto end = fbb_.EndTable(start_);
9123 auto o = flatbuffers::Offset<StandInDescriptor>(end);
9129 flatbuffers::FlatBufferBuilder &_fbb,
9130 uint32_t numInputs = 0,
9131 uint32_t numOutputs = 0) {
9135 return builder_.
Finish();
9138 struct StandInLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9140 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9144 const armnnSerializer::LayerBase *
base()
const {
9145 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9148 return GetPointer<const armnnSerializer::StandInDescriptor *>(
VT_DESCRIPTOR);
9150 bool Verify(flatbuffers::Verifier &verifier)
const {
9151 return VerifyTableStart(verifier) &&
9152 VerifyOffset(verifier,
VT_BASE) &&
9153 verifier.VerifyTable(base()) &&
9155 verifier.VerifyTable(descriptor()) &&
9156 verifier.EndTable();
9162 flatbuffers::FlatBufferBuilder &
fbb_;
9164 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9167 void add_descriptor(flatbuffers::Offset<armnnSerializer::StandInDescriptor> descriptor) {
9172 start_ = fbb_.StartTable();
9176 const auto end = fbb_.EndTable(start_);
9177 auto o = flatbuffers::Offset<StandInLayer>(end);
9183 flatbuffers::FlatBufferBuilder &_fbb,
9184 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9185 flatbuffers::Offset<armnnSerializer::StandInDescriptor> descriptor = 0) {
9189 return builder_.
Finish();
9192 struct RankLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9194 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9197 const armnnSerializer::LayerBase *
base()
const {
9198 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9200 bool Verify(flatbuffers::Verifier &verifier)
const {
9201 return VerifyTableStart(verifier) &&
9202 VerifyOffset(verifier,
VT_BASE) &&
9203 verifier.VerifyTable(base()) &&
9204 verifier.EndTable();
9210 flatbuffers::FlatBufferBuilder &
fbb_;
9212 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9217 start_ = fbb_.StartTable();
9221 const auto end = fbb_.EndTable(start_);
9222 auto o = flatbuffers::Offset<RankLayer>(end);
9228 flatbuffers::FlatBufferBuilder &_fbb,
9229 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
9232 return builder_.
Finish();
9235 struct ReduceLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9237 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9241 const armnnSerializer::LayerBase *
base()
const {
9242 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9245 return GetPointer<const armnnSerializer::ReduceDescriptor *>(
VT_DESCRIPTOR);
9247 bool Verify(flatbuffers::Verifier &verifier)
const {
9248 return VerifyTableStart(verifier) &&
9249 VerifyOffset(verifier,
VT_BASE) &&
9250 verifier.VerifyTable(base()) &&
9252 verifier.VerifyTable(descriptor()) &&
9253 verifier.EndTable();
9259 flatbuffers::FlatBufferBuilder &
fbb_;
9261 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9264 void add_descriptor(flatbuffers::Offset<armnnSerializer::ReduceDescriptor> descriptor) {
9269 start_ = fbb_.StartTable();
9273 const auto end = fbb_.EndTable(start_);
9274 auto o = flatbuffers::Offset<ReduceLayer>(end);
9280 flatbuffers::FlatBufferBuilder &_fbb,
9281 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9282 flatbuffers::Offset<armnnSerializer::ReduceDescriptor> descriptor = 0) {
9286 return builder_.
Finish();
9289 struct ReduceDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9291 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9294 VT_REDUCEOPERATION = 8
9299 const flatbuffers::Vector<uint32_t> *
axis()
const {
9300 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_AXIS);
9305 bool Verify(flatbuffers::Verifier &verifier)
const {
9306 return VerifyTableStart(verifier) &&
9308 VerifyOffset(verifier,
VT_AXIS) &&
9309 verifier.VerifyVector(axis()) &&
9310 VerifyField<int8_t>(verifier, VT_REDUCEOPERATION) &&
9311 verifier.EndTable();
9317 flatbuffers::FlatBufferBuilder &
fbb_;
9326 fbb_.AddElement<int8_t>(ReduceDescriptor::VT_REDUCEOPERATION,
static_cast<int8_t
>(reduceOperation), 0);
9330 start_ = fbb_.StartTable();
9333 flatbuffers::Offset<ReduceDescriptor>
Finish() {
9334 const auto end = fbb_.EndTable(start_);
9335 auto o = flatbuffers::Offset<ReduceDescriptor>(end);
9341 flatbuffers::FlatBufferBuilder &_fbb,
9342 bool keepDims =
false,
9349 return builder_.
Finish();
9353 flatbuffers::FlatBufferBuilder &_fbb,
9354 bool keepDims =
false,
9355 const std::vector<uint32_t> *axis =
nullptr,
9357 auto axis__ = axis ? _fbb.CreateVector<uint32_t>(*axis) : 0;
9365 struct AnyLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9367 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9375 return GetPointer<const void *>(VT_LAYER);
9377 template<
typename T>
const T *layer_as()
const;
9564 bool Verify(flatbuffers::Verifier &verifier)
const {
9565 return VerifyTableStart(verifier) &&
9567 VerifyOffset(verifier, VT_LAYER) &&
9569 verifier.EndTable();
9573 template<>
inline const armnnSerializer::ActivationLayer *AnyLayer::layer_as<armnnSerializer::ActivationLayer>()
const {
9574 return layer_as_ActivationLayer();
9577 template<>
inline const armnnSerializer::AdditionLayer *AnyLayer::layer_as<armnnSerializer::AdditionLayer>()
const {
9578 return layer_as_AdditionLayer();
9581 template<>
inline const armnnSerializer::BatchToSpaceNdLayer *AnyLayer::layer_as<armnnSerializer::BatchToSpaceNdLayer>()
const {
9582 return layer_as_BatchToSpaceNdLayer();
9585 template<>
inline const armnnSerializer::BatchNormalizationLayer *AnyLayer::layer_as<armnnSerializer::BatchNormalizationLayer>()
const {
9586 return layer_as_BatchNormalizationLayer();
9589 template<>
inline const armnnSerializer::ConstantLayer *AnyLayer::layer_as<armnnSerializer::ConstantLayer>()
const {
9590 return layer_as_ConstantLayer();
9593 template<>
inline const armnnSerializer::Convolution2dLayer *AnyLayer::layer_as<armnnSerializer::Convolution2dLayer>()
const {
9594 return layer_as_Convolution2dLayer();
9597 template<>
inline const armnnSerializer::DepthwiseConvolution2dLayer *AnyLayer::layer_as<armnnSerializer::DepthwiseConvolution2dLayer>()
const {
9598 return layer_as_DepthwiseConvolution2dLayer();
9601 template<>
inline const armnnSerializer::FullyConnectedLayer *AnyLayer::layer_as<armnnSerializer::FullyConnectedLayer>()
const {
9602 return layer_as_FullyConnectedLayer();
9605 template<>
inline const armnnSerializer::InputLayer *AnyLayer::layer_as<armnnSerializer::InputLayer>()
const {
9606 return layer_as_InputLayer();
9609 template<>
inline const armnnSerializer::MultiplicationLayer *AnyLayer::layer_as<armnnSerializer::MultiplicationLayer>()
const {
9610 return layer_as_MultiplicationLayer();
9613 template<>
inline const armnnSerializer::OutputLayer *AnyLayer::layer_as<armnnSerializer::OutputLayer>()
const {
9614 return layer_as_OutputLayer();
9617 template<>
inline const armnnSerializer::PermuteLayer *AnyLayer::layer_as<armnnSerializer::PermuteLayer>()
const {
9618 return layer_as_PermuteLayer();
9621 template<>
inline const armnnSerializer::Pooling2dLayer *AnyLayer::layer_as<armnnSerializer::Pooling2dLayer>()
const {
9622 return layer_as_Pooling2dLayer();
9625 template<>
inline const armnnSerializer::ReshapeLayer *AnyLayer::layer_as<armnnSerializer::ReshapeLayer>()
const {
9626 return layer_as_ReshapeLayer();
9629 template<>
inline const armnnSerializer::SoftmaxLayer *AnyLayer::layer_as<armnnSerializer::SoftmaxLayer>()
const {
9630 return layer_as_SoftmaxLayer();
9633 template<>
inline const armnnSerializer::SpaceToBatchNdLayer *AnyLayer::layer_as<armnnSerializer::SpaceToBatchNdLayer>()
const {
9634 return layer_as_SpaceToBatchNdLayer();
9637 template<>
inline const armnnSerializer::DivisionLayer *AnyLayer::layer_as<armnnSerializer::DivisionLayer>()
const {
9638 return layer_as_DivisionLayer();
9641 template<>
inline const armnnSerializer::MinimumLayer *AnyLayer::layer_as<armnnSerializer::MinimumLayer>()
const {
9642 return layer_as_MinimumLayer();
9645 template<>
inline const armnnSerializer::EqualLayer *AnyLayer::layer_as<armnnSerializer::EqualLayer>()
const {
9646 return layer_as_EqualLayer();
9649 template<>
inline const armnnSerializer::MaximumLayer *AnyLayer::layer_as<armnnSerializer::MaximumLayer>()
const {
9650 return layer_as_MaximumLayer();
9653 template<>
inline const armnnSerializer::NormalizationLayer *AnyLayer::layer_as<armnnSerializer::NormalizationLayer>()
const {
9654 return layer_as_NormalizationLayer();
9657 template<>
inline const armnnSerializer::PadLayer *AnyLayer::layer_as<armnnSerializer::PadLayer>()
const {
9658 return layer_as_PadLayer();
9661 template<>
inline const armnnSerializer::RsqrtLayer *AnyLayer::layer_as<armnnSerializer::RsqrtLayer>()
const {
9662 return layer_as_RsqrtLayer();
9665 template<>
inline const armnnSerializer::FloorLayer *AnyLayer::layer_as<armnnSerializer::FloorLayer>()
const {
9666 return layer_as_FloorLayer();
9669 template<>
inline const armnnSerializer::GreaterLayer *AnyLayer::layer_as<armnnSerializer::GreaterLayer>()
const {
9670 return layer_as_GreaterLayer();
9673 template<>
inline const armnnSerializer::ResizeBilinearLayer *AnyLayer::layer_as<armnnSerializer::ResizeBilinearLayer>()
const {
9674 return layer_as_ResizeBilinearLayer();
9677 template<>
inline const armnnSerializer::SubtractionLayer *AnyLayer::layer_as<armnnSerializer::SubtractionLayer>()
const {
9678 return layer_as_SubtractionLayer();
9681 template<>
inline const armnnSerializer::StridedSliceLayer *AnyLayer::layer_as<armnnSerializer::StridedSliceLayer>()
const {
9682 return layer_as_StridedSliceLayer();
9685 template<>
inline const armnnSerializer::GatherLayer *AnyLayer::layer_as<armnnSerializer::GatherLayer>()
const {
9686 return layer_as_GatherLayer();
9689 template<>
inline const armnnSerializer::MeanLayer *AnyLayer::layer_as<armnnSerializer::MeanLayer>()
const {
9690 return layer_as_MeanLayer();
9694 return layer_as_MergerLayer();
9697 template<>
inline const armnnSerializer::L2NormalizationLayer *AnyLayer::layer_as<armnnSerializer::L2NormalizationLayer>()
const {
9698 return layer_as_L2NormalizationLayer();
9701 template<>
inline const armnnSerializer::SplitterLayer *AnyLayer::layer_as<armnnSerializer::SplitterLayer>()
const {
9702 return layer_as_SplitterLayer();
9705 template<>
inline const armnnSerializer::DetectionPostProcessLayer *AnyLayer::layer_as<armnnSerializer::DetectionPostProcessLayer>()
const {
9706 return layer_as_DetectionPostProcessLayer();
9709 template<>
inline const armnnSerializer::LstmLayer *AnyLayer::layer_as<armnnSerializer::LstmLayer>()
const {
9710 return layer_as_LstmLayer();
9713 template<>
inline const armnnSerializer::QuantizedLstmLayer *AnyLayer::layer_as<armnnSerializer::QuantizedLstmLayer>()
const {
9714 return layer_as_QuantizedLstmLayer();
9717 template<>
inline const armnnSerializer::QuantizeLayer *AnyLayer::layer_as<armnnSerializer::QuantizeLayer>()
const {
9718 return layer_as_QuantizeLayer();
9721 template<>
inline const armnnSerializer::DequantizeLayer *AnyLayer::layer_as<armnnSerializer::DequantizeLayer>()
const {
9722 return layer_as_DequantizeLayer();
9725 template<>
inline const armnnSerializer::MergeLayer *AnyLayer::layer_as<armnnSerializer::MergeLayer>()
const {
9726 return layer_as_MergeLayer();
9729 template<>
inline const armnnSerializer::SwitchLayer *AnyLayer::layer_as<armnnSerializer::SwitchLayer>()
const {
9730 return layer_as_SwitchLayer();
9733 template<>
inline const armnnSerializer::ConcatLayer *AnyLayer::layer_as<armnnSerializer::ConcatLayer>()
const {
9734 return layer_as_ConcatLayer();
9737 template<>
inline const armnnSerializer::SpaceToDepthLayer *AnyLayer::layer_as<armnnSerializer::SpaceToDepthLayer>()
const {
9738 return layer_as_SpaceToDepthLayer();
9741 template<>
inline const armnnSerializer::PreluLayer *AnyLayer::layer_as<armnnSerializer::PreluLayer>()
const {
9742 return layer_as_PreluLayer();
9745 template<>
inline const armnnSerializer::TransposeConvolution2dLayer *AnyLayer::layer_as<armnnSerializer::TransposeConvolution2dLayer>()
const {
9746 return layer_as_TransposeConvolution2dLayer();
9749 template<>
inline const armnnSerializer::ResizeLayer *AnyLayer::layer_as<armnnSerializer::ResizeLayer>()
const {
9750 return layer_as_ResizeLayer();
9753 template<>
inline const armnnSerializer::StackLayer *AnyLayer::layer_as<armnnSerializer::StackLayer>()
const {
9754 return layer_as_StackLayer();
9757 template<>
inline const armnnSerializer::AbsLayer *AnyLayer::layer_as<armnnSerializer::AbsLayer>()
const {
9758 return layer_as_AbsLayer();
9761 template<>
inline const armnnSerializer::ArgMinMaxLayer *AnyLayer::layer_as<armnnSerializer::ArgMinMaxLayer>()
const {
9762 return layer_as_ArgMinMaxLayer();
9765 template<>
inline const armnnSerializer::SliceLayer *AnyLayer::layer_as<armnnSerializer::SliceLayer>()
const {
9766 return layer_as_SliceLayer();
9769 template<>
inline const armnnSerializer::DepthToSpaceLayer *AnyLayer::layer_as<armnnSerializer::DepthToSpaceLayer>()
const {
9770 return layer_as_DepthToSpaceLayer();
9773 template<>
inline const armnnSerializer::InstanceNormalizationLayer *AnyLayer::layer_as<armnnSerializer::InstanceNormalizationLayer>()
const {
9774 return layer_as_InstanceNormalizationLayer();
9777 template<>
inline const armnnSerializer::LogSoftmaxLayer *AnyLayer::layer_as<armnnSerializer::LogSoftmaxLayer>()
const {
9778 return layer_as_LogSoftmaxLayer();
9781 template<>
inline const armnnSerializer::ComparisonLayer *AnyLayer::layer_as<armnnSerializer::ComparisonLayer>()
const {
9782 return layer_as_ComparisonLayer();
9785 template<>
inline const armnnSerializer::StandInLayer *AnyLayer::layer_as<armnnSerializer::StandInLayer>()
const {
9786 return layer_as_StandInLayer();
9789 template<>
inline const armnnSerializer::ElementwiseUnaryLayer *AnyLayer::layer_as<armnnSerializer::ElementwiseUnaryLayer>()
const {
9790 return layer_as_ElementwiseUnaryLayer();
9793 template<>
inline const armnnSerializer::TransposeLayer *AnyLayer::layer_as<armnnSerializer::TransposeLayer>()
const {
9794 return layer_as_TransposeLayer();
9797 template<>
inline const armnnSerializer::QLstmLayer *AnyLayer::layer_as<armnnSerializer::QLstmLayer>()
const {
9798 return layer_as_QLstmLayer();
9801 template<>
inline const armnnSerializer::FillLayer *AnyLayer::layer_as<armnnSerializer::FillLayer>()
const {
9802 return layer_as_FillLayer();
9805 template<>
inline const armnnSerializer::RankLayer *AnyLayer::layer_as<armnnSerializer::RankLayer>()
const {
9806 return layer_as_RankLayer();
9809 template<>
inline const armnnSerializer::LogicalBinaryLayer *AnyLayer::layer_as<armnnSerializer::LogicalBinaryLayer>()
const {
9810 return layer_as_LogicalBinaryLayer();
9813 template<>
inline const armnnSerializer::ReduceLayer *AnyLayer::layer_as<armnnSerializer::ReduceLayer>()
const {
9814 return layer_as_ReduceLayer();
9817 template<>
inline const armnnSerializer::CastLayer *AnyLayer::layer_as<armnnSerializer::CastLayer>()
const {
9818 return layer_as_CastLayer();
9823 flatbuffers::FlatBufferBuilder &
fbb_;
9829 fbb_.AddOffset(AnyLayer::VT_LAYER, layer);
9833 start_ = fbb_.StartTable();
9837 const auto end = fbb_.EndTable(start_);
9838 auto o = flatbuffers::Offset<AnyLayer>(end);
9844 flatbuffers::FlatBufferBuilder &_fbb,
9846 flatbuffers::Offset<void> layer = 0) {
9850 return builder_.
Finish();
9853 struct FeatureCompatibilityVersions FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9855 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9856 VT_BINDINGIDSSCHEME = 4
9859 return GetField<uint32_t>(VT_BINDINGIDSSCHEME, 0);
9861 bool Verify(flatbuffers::Verifier &verifier)
const {
9862 return VerifyTableStart(verifier) &&
9863 VerifyField<uint32_t>(verifier, VT_BINDINGIDSSCHEME) &&
9864 verifier.EndTable();
9869 typedef FeatureCompatibilityVersions
Table;
9870 flatbuffers::FlatBufferBuilder &
fbb_;
9873 fbb_.AddElement<uint32_t>(FeatureCompatibilityVersions::VT_BINDINGIDSSCHEME, bindingIdsScheme, 0);
9877 start_ = fbb_.StartTable();
9880 flatbuffers::Offset<FeatureCompatibilityVersions>
Finish() {
9881 const auto end = fbb_.EndTable(start_);
9882 auto o = flatbuffers::Offset<FeatureCompatibilityVersions>(end);
9888 flatbuffers::FlatBufferBuilder &_fbb,
9889 uint32_t bindingIdsScheme = 0) {
9892 return builder_.
Finish();
9895 struct SerializedGraph FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9897 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9901 VT_FEATUREVERSIONS = 10
9903 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::AnyLayer>> *
layers()
const {
9904 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::AnyLayer>> *>(
VT_LAYERS);
9907 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_INPUTIDS);
9910 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_OUTPUTIDS);
9913 return GetPointer<const armnnSerializer::FeatureCompatibilityVersions *>(VT_FEATUREVERSIONS);
9915 bool Verify(flatbuffers::Verifier &verifier)
const {
9916 return VerifyTableStart(verifier) &&
9918 verifier.VerifyVector(layers()) &&
9919 verifier.VerifyVectorOfTables(layers()) &&
9921 verifier.VerifyVector(inputIds()) &&
9923 verifier.VerifyVector(outputIds()) &&
9924 VerifyOffset(verifier, VT_FEATUREVERSIONS) &&
9925 verifier.VerifyTable(featureVersions()) &&
9926 verifier.EndTable();
9932 flatbuffers::FlatBufferBuilder &
fbb_;
9943 void add_featureVersions(flatbuffers::Offset<armnnSerializer::FeatureCompatibilityVersions> featureVersions) {
9944 fbb_.AddOffset(SerializedGraph::VT_FEATUREVERSIONS, featureVersions);
9948 start_ = fbb_.StartTable();
9951 flatbuffers::Offset<SerializedGraph>
Finish() {
9952 const auto end = fbb_.EndTable(start_);
9953 auto o = flatbuffers::Offset<SerializedGraph>(end);
9959 flatbuffers::FlatBufferBuilder &_fbb,
9960 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::AnyLayer>>> layers = 0,
9963 flatbuffers::Offset<armnnSerializer::FeatureCompatibilityVersions> featureVersions = 0) {
9969 return builder_.
Finish();
9973 flatbuffers::FlatBufferBuilder &_fbb,
9974 const std::vector<flatbuffers::Offset<armnnSerializer::AnyLayer>> *layers =
nullptr,
9975 const std::vector<int32_t> *inputIds =
nullptr,
9976 const std::vector<int32_t> *outputIds =
nullptr,
9977 flatbuffers::Offset<armnnSerializer::FeatureCompatibilityVersions> featureVersions = 0) {
9978 auto layers__ = layers ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::AnyLayer>>(*layers) : 0;
9979 auto inputIds__ = inputIds ? _fbb.CreateVector<int32_t>(*inputIds) : 0;
9980 auto outputIds__ = outputIds ? _fbb.CreateVector<int32_t>(*outputIds) : 0;
9995 auto ptr =
reinterpret_cast<const armnnSerializer::ByteData *
>(obj);
9996 return verifier.VerifyTable(ptr);
9999 auto ptr =
reinterpret_cast<const armnnSerializer::ShortData *
>(obj);
10000 return verifier.VerifyTable(ptr);
10003 auto ptr =
reinterpret_cast<const armnnSerializer::IntData *
>(obj);
10004 return verifier.VerifyTable(ptr);
10007 auto ptr =
reinterpret_cast<const armnnSerializer::LongData *
>(obj);
10008 return verifier.VerifyTable(ptr);
10010 default:
return true;
10014 inline bool VerifyConstTensorDataVector(flatbuffers::Verifier &verifier,
const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
const flatbuffers::Vector<uint8_t> *types) {
10015 if (!values || !types)
return !values && !types;
10016 if (values->size() != types->size())
return false;
10017 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
10032 auto ptr =
reinterpret_cast<const armnnSerializer::ActivationLayer *
>(obj);
10033 return verifier.VerifyTable(ptr);
10036 auto ptr =
reinterpret_cast<const armnnSerializer::AdditionLayer *
>(obj);
10037 return verifier.VerifyTable(ptr);
10040 auto ptr =
reinterpret_cast<const armnnSerializer::BatchToSpaceNdLayer *
>(obj);
10041 return verifier.VerifyTable(ptr);
10044 auto ptr =
reinterpret_cast<const armnnSerializer::BatchNormalizationLayer *
>(obj);
10045 return verifier.VerifyTable(ptr);
10048 auto ptr =
reinterpret_cast<const armnnSerializer::ConstantLayer *
>(obj);
10049 return verifier.VerifyTable(ptr);
10052 auto ptr =
reinterpret_cast<const armnnSerializer::Convolution2dLayer *
>(obj);
10053 return verifier.VerifyTable(ptr);
10056 auto ptr =
reinterpret_cast<const armnnSerializer::DepthwiseConvolution2dLayer *
>(obj);
10057 return verifier.VerifyTable(ptr);
10060 auto ptr =
reinterpret_cast<const armnnSerializer::FullyConnectedLayer *
>(obj);
10061 return verifier.VerifyTable(ptr);
10064 auto ptr =
reinterpret_cast<const armnnSerializer::InputLayer *
>(obj);
10065 return verifier.VerifyTable(ptr);
10068 auto ptr =
reinterpret_cast<const armnnSerializer::MultiplicationLayer *
>(obj);
10069 return verifier.VerifyTable(ptr);
10072 auto ptr =
reinterpret_cast<const armnnSerializer::OutputLayer *
>(obj);
10073 return verifier.VerifyTable(ptr);
10076 auto ptr =
reinterpret_cast<const armnnSerializer::PermuteLayer *
>(obj);
10077 return verifier.VerifyTable(ptr);
10080 auto ptr =
reinterpret_cast<const armnnSerializer::Pooling2dLayer *
>(obj);
10081 return verifier.VerifyTable(ptr);
10084 auto ptr =
reinterpret_cast<const armnnSerializer::ReshapeLayer *
>(obj);
10085 return verifier.VerifyTable(ptr);
10088 auto ptr =
reinterpret_cast<const armnnSerializer::SoftmaxLayer *
>(obj);
10089 return verifier.VerifyTable(ptr);
10092 auto ptr =
reinterpret_cast<const armnnSerializer::SpaceToBatchNdLayer *
>(obj);
10093 return verifier.VerifyTable(ptr);
10096 auto ptr =
reinterpret_cast<const armnnSerializer::DivisionLayer *
>(obj);
10097 return verifier.VerifyTable(ptr);
10100 auto ptr =
reinterpret_cast<const armnnSerializer::MinimumLayer *
>(obj);
10101 return verifier.VerifyTable(ptr);
10104 auto ptr =
reinterpret_cast<const armnnSerializer::EqualLayer *
>(obj);
10105 return verifier.VerifyTable(ptr);
10108 auto ptr =
reinterpret_cast<const armnnSerializer::MaximumLayer *
>(obj);
10109 return verifier.VerifyTable(ptr);
10112 auto ptr =
reinterpret_cast<const armnnSerializer::NormalizationLayer *
>(obj);
10113 return verifier.VerifyTable(ptr);
10116 auto ptr =
reinterpret_cast<const armnnSerializer::PadLayer *
>(obj);
10117 return verifier.VerifyTable(ptr);
10120 auto ptr =
reinterpret_cast<const armnnSerializer::RsqrtLayer *
>(obj);
10121 return verifier.VerifyTable(ptr);
10124 auto ptr =
reinterpret_cast<const armnnSerializer::FloorLayer *
>(obj);
10125 return verifier.VerifyTable(ptr);
10128 auto ptr =
reinterpret_cast<const armnnSerializer::GreaterLayer *
>(obj);
10129 return verifier.VerifyTable(ptr);
10132 auto ptr =
reinterpret_cast<const armnnSerializer::ResizeBilinearLayer *
>(obj);
10133 return verifier.VerifyTable(ptr);
10136 auto ptr =
reinterpret_cast<const armnnSerializer::SubtractionLayer *
>(obj);
10137 return verifier.VerifyTable(ptr);
10140 auto ptr =
reinterpret_cast<const armnnSerializer::StridedSliceLayer *
>(obj);
10141 return verifier.VerifyTable(ptr);
10144 auto ptr =
reinterpret_cast<const armnnSerializer::GatherLayer *
>(obj);
10145 return verifier.VerifyTable(ptr);
10148 auto ptr =
reinterpret_cast<const armnnSerializer::MeanLayer *
>(obj);
10149 return verifier.VerifyTable(ptr);
10153 return verifier.VerifyTable(ptr);
10156 auto ptr =
reinterpret_cast<const armnnSerializer::L2NormalizationLayer *
>(obj);
10157 return verifier.VerifyTable(ptr);
10160 auto ptr =
reinterpret_cast<const armnnSerializer::SplitterLayer *
>(obj);
10161 return verifier.VerifyTable(ptr);
10164 auto ptr =
reinterpret_cast<const armnnSerializer::DetectionPostProcessLayer *
>(obj);
10165 return verifier.VerifyTable(ptr);
10168 auto ptr =
reinterpret_cast<const armnnSerializer::LstmLayer *
>(obj);
10169 return verifier.VerifyTable(ptr);
10172 auto ptr =
reinterpret_cast<const armnnSerializer::QuantizedLstmLayer *
>(obj);
10173 return verifier.VerifyTable(ptr);
10176 auto ptr =
reinterpret_cast<const armnnSerializer::QuantizeLayer *
>(obj);
10177 return verifier.VerifyTable(ptr);
10180 auto ptr =
reinterpret_cast<const armnnSerializer::DequantizeLayer *
>(obj);
10181 return verifier.VerifyTable(ptr);
10184 auto ptr =
reinterpret_cast<const armnnSerializer::MergeLayer *
>(obj);
10185 return verifier.VerifyTable(ptr);
10188 auto ptr =
reinterpret_cast<const armnnSerializer::SwitchLayer *
>(obj);
10189 return verifier.VerifyTable(ptr);
10192 auto ptr =
reinterpret_cast<const armnnSerializer::ConcatLayer *
>(obj);
10193 return verifier.VerifyTable(ptr);
10196 auto ptr =
reinterpret_cast<const armnnSerializer::SpaceToDepthLayer *
>(obj);
10197 return verifier.VerifyTable(ptr);
10200 auto ptr =
reinterpret_cast<const armnnSerializer::PreluLayer *
>(obj);
10201 return verifier.VerifyTable(ptr);
10204 auto ptr =
reinterpret_cast<const armnnSerializer::TransposeConvolution2dLayer *
>(obj);
10205 return verifier.VerifyTable(ptr);
10208 auto ptr =
reinterpret_cast<const armnnSerializer::ResizeLayer *
>(obj);
10209 return verifier.VerifyTable(ptr);
10212 auto ptr =
reinterpret_cast<const armnnSerializer::StackLayer *
>(obj);
10213 return verifier.VerifyTable(ptr);
10216 auto ptr =
reinterpret_cast<const armnnSerializer::AbsLayer *
>(obj);
10217 return verifier.VerifyTable(ptr);
10220 auto ptr =
reinterpret_cast<const armnnSerializer::ArgMinMaxLayer *
>(obj);
10221 return verifier.VerifyTable(ptr);
10224 auto ptr =
reinterpret_cast<const armnnSerializer::SliceLayer *
>(obj);
10225 return verifier.VerifyTable(ptr);
10228 auto ptr =
reinterpret_cast<const armnnSerializer::DepthToSpaceLayer *
>(obj);
10229 return verifier.VerifyTable(ptr);
10232 auto ptr =
reinterpret_cast<const armnnSerializer::InstanceNormalizationLayer *
>(obj);
10233 return verifier.VerifyTable(ptr);
10236 auto ptr =
reinterpret_cast<const armnnSerializer::LogSoftmaxLayer *
>(obj);
10237 return verifier.VerifyTable(ptr);
10240 auto ptr =
reinterpret_cast<const armnnSerializer::ComparisonLayer *
>(obj);
10241 return verifier.VerifyTable(ptr);
10244 auto ptr =
reinterpret_cast<const armnnSerializer::StandInLayer *
>(obj);
10245 return verifier.VerifyTable(ptr);
10248 auto ptr =
reinterpret_cast<const armnnSerializer::ElementwiseUnaryLayer *
>(obj);
10249 return verifier.VerifyTable(ptr);
10252 auto ptr =
reinterpret_cast<const armnnSerializer::TransposeLayer *
>(obj);
10253 return verifier.VerifyTable(ptr);
10256 auto ptr =
reinterpret_cast<const armnnSerializer::QLstmLayer *
>(obj);
10257 return verifier.VerifyTable(ptr);
10260 auto ptr =
reinterpret_cast<const armnnSerializer::FillLayer *
>(obj);
10261 return verifier.VerifyTable(ptr);
10264 auto ptr =
reinterpret_cast<const armnnSerializer::RankLayer *
>(obj);
10265 return verifier.VerifyTable(ptr);
10268 auto ptr =
reinterpret_cast<const armnnSerializer::LogicalBinaryLayer *
>(obj);
10269 return verifier.VerifyTable(ptr);
10272 auto ptr =
reinterpret_cast<const armnnSerializer::ReduceLayer *
>(obj);
10273 return verifier.VerifyTable(ptr);
10276 auto ptr =
reinterpret_cast<const armnnSerializer::CastLayer *
>(obj);
10277 return verifier.VerifyTable(ptr);
10279 default:
return true;
10283 inline bool VerifyLayerVector(flatbuffers::Verifier &verifier,
const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
const flatbuffers::Vector<uint8_t> *types) {
10284 if (!values || !types)
return !values && !types;
10285 if (values->size() != types->size())
return false;
10286 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
10288 verifier, values->Get(i), types->GetEnum<
Layer>(i))) {
10296 return flatbuffers::GetRoot<armnnSerializer::SerializedGraph>(buf);
10300 return flatbuffers::GetSizePrefixedRoot<armnnSerializer::SerializedGraph>(buf);
10308 return flatbuffers::BufferHasIdentifier(
10313 flatbuffers::Verifier &verifier) {
10318 flatbuffers::Verifier &verifier) {
10327 flatbuffers::FlatBufferBuilder &fbb,
10328 flatbuffers::Offset<armnnSerializer::SerializedGraph> root) {
10333 flatbuffers::FlatBufferBuilder &fbb,
10334 flatbuffers::Offset<armnnSerializer::SerializedGraph> root) {
10340 #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< CastLayer > Finish()
flatbuffers::Offset< TensorInfo > Finish()
const armnnSerializer::RankLayer * layer_as_RankLayer() const
LogSoftmaxDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_poolType(armnnSerializer::PoolingAlgorithm poolType)
flatbuffers::Offset< DepthToSpaceDescriptor > Finish()
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
MultiplicationLayerBuilder Builder
flatbuffers::uoffset_t start_
void add_descriptor(flatbuffers::Offset< armnnSerializer::NormalizationDescriptor > descriptor)
flatbuffers::Offset< DepthToSpaceLayer > Finish()
float projectionClip() const
void add_normSize(uint32_t normSize)
const armnnSerializer::ConstTensor * inputToOutputWeights() const
ConstantLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_anchors(flatbuffers::Offset< armnnSerializer::ConstTensor > anchors)
uint32_t numClasses() const
const armnnSerializer::AdditionLayer * layer_as_AdditionLayer() const
ReduceDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< SplitterLayer > Finish()
flatbuffers::Offset< LongData > CreateLongData(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< int64_t >> data=0)
void add_scaleW(float scaleW)
uint32_t targetHeight() const
flatbuffers::uoffset_t start_
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
ElementwiseUnaryLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_ellipsisMask(int32_t ellipsisMask)
flatbuffers::FlatBufferBuilder & fbb_
MinimumLayerBuilder Builder
flatbuffers::Offset< LongData > Finish()
void add_strideX(uint32_t strideX)
flatbuffers::uoffset_t start_
flatbuffers::Offset< ElementwiseUnaryDescriptor > Finish()
FullyConnectedDescriptor Table
const armnnSerializer::MaximumLayer * layer_as_MaximumLayer() const
ElementwiseUnaryDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
TransposeLayerBuilder Builder
void add_descriptor(flatbuffers::Offset< armnnSerializer::ResizeBilinearDescriptor > descriptor)
ViewsDescriptorBuilder Builder
QuantizedLstmLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< ReshapeDescriptor > CreateReshapeDescriptor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> targetShape=0)
const armnnSerializer::SliceLayer * layer_as_SliceLayer() const
flatbuffers::FlatBufferBuilder & fbb_
SubtractionLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
RsqrtLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< ReduceLayer > CreateReduceLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ReduceDescriptor > descriptor=0)
void add_descriptor(flatbuffers::Offset< armnnSerializer::SpaceToBatchNdDescriptor > descriptor)
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
int32_t beginMask() const
const armnnSerializer::ConcatLayer * layer_as_ConcatLayer() const
static const ConstTensorData enum_value
flatbuffers::uoffset_t start_
void add_info(flatbuffers::Offset< armnnSerializer::TensorInfo > info)
flatbuffers::Offset< SerializedGraph > CreateSerializedGraphDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< flatbuffers::Offset< armnnSerializer::AnyLayer >> *layers=nullptr, const std::vector< int32_t > *inputIds=nullptr, const std::vector< int32_t > *outputIds=nullptr, flatbuffers::Offset< armnnSerializer::FeatureCompatibilityVersions > featureVersions=0)
ConcatLayerBuilder Builder
const char * EnumNameUnaryOperation(UnaryOperation e)
flatbuffers::Offset< PermuteLayer > Finish()
const armnnSerializer::ConstTensor * inputGateBias() const
const armnnSerializer::NormalizationLayer * layer_as_NormalizationLayer() const
void add_layerNormEnabled(bool layerNormEnabled)
BatchToSpaceNdLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::FillDescriptor * descriptor() const
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)
const armnnSerializer::CastLayer * layer_as_CastLayer() const
LstmLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_descriptor(flatbuffers::Offset< armnnSerializer::TransposeDescriptor > descriptor)
flatbuffers::Offset< ActivationLayer > Finish()
BatchNormalizationLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
bool VerifyLayerVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector< flatbuffers::Offset< void >> *values, const flatbuffers::Vector< uint8_t > *types)
void add_descriptor(flatbuffers::Offset< armnnSerializer::BatchToSpaceNdDescriptor > descriptor)
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()
const DataType(& EnumValuesDataType())[11]
flatbuffers::Offset< MergerLayer > CreateMergerLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::OriginsDescriptor > descriptor=0)
flatbuffers::uoffset_t start_
void add_padRight(uint32_t padRight)
flatbuffers::Offset< AbsLayer > CreateAbsLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
flatbuffers::Offset< LstmLayer > CreateLstmLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::LstmDescriptor > descriptor=0, flatbuffers::Offset< armnnSerializer::LstmInputParams > inputParams=0)
uint32_t padRight() const
flatbuffers::Offset< PermuteDescriptor > Finish()
flatbuffers::Offset< L2NormalizationLayer > CreateL2NormalizationLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::L2NormalizationDescriptor > descriptor=0)
flatbuffers::FlatBufferBuilder & fbb_
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::FlatBufferBuilder & fbb_
void add_constantWeights(bool constantWeights)
const armnnSerializer::Convolution2dLayer * layer_as_Convolution2dLayer() const
ConstTensorBuilder Builder
const flatbuffers::Vector< int16_t > * data() const
const flatbuffers::Vector< uint32_t > * blockShape() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_method(armnnSerializer::ResizeMethod method)
flatbuffers::uoffset_t start_
void add_padTop(uint32_t padTop)
flatbuffers::Offset< TransposeConvolution2dDescriptor > CreateTransposeConvolution2dDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t padLeft=0, uint32_t padRight=0, uint32_t padTop=0, uint32_t padBottom=0, uint32_t strideX=0, uint32_t strideY=0, bool biasEnabled=false, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NCHW)
void add_index(uint32_t index)
flatbuffers::Offset< GatherLayer > Finish()
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)
flatbuffers::uoffset_t start_
InstanceNormalizationLayer Table
void add_padList(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> padList)
flatbuffers::Offset< AdditionLayer > Finish()
MaximumLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const char * EnumNameReduceOperation(ReduceOperation e)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
DepthwiseConvolution2dLayer Table
void add_padTop(uint32_t padTop)
void add_transposeWeightsMatrix(bool transposeWeightsMatrix)
const armnnSerializer::ConstTensor * inputLayerNormWeights() const
FeatureCompatibilityVersions Table
PreluLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
DequantizeLayerBuilder Builder
void add_keepDims(bool keepDims)
const armnnSerializer::ResizeBilinearLayer * layer_as_ResizeBilinearLayer() const
flatbuffers::Offset< ConstTensor > CreateConstTensor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::TensorInfo > info=0, armnnSerializer::ConstTensorData data_type=armnnSerializer::ConstTensorData_NONE, flatbuffers::Offset< void > data=0)
float nmsIouThreshold() const
QLstmLayerBuilder Builder
void add_crops(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> crops)
flatbuffers::Offset< QuantizeLayer > CreateQuantizeLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::DivisionLayer * layer_as_DivisionLayer() const
const armnnSerializer::TransposeDescriptor * descriptor() const
QLstmDescriptorBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
const flatbuffers::Vector< int32_t > * begin() const
void add_biasEnabled(bool biasEnabled)
const armnnSerializer::Pooling2dLayer * layer_as_Pooling2dLayer() const
MeanDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const PaddingMethod(& EnumValuesPaddingMethod())[2]
StridedSliceLayerBuilder Builder
void add_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_
const Layer(& EnumValuesLayer())[63]
flatbuffers::FlatBufferBuilder & fbb_
ResizeBilinearLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< SpaceToDepthDescriptor > CreateSpaceToDepthDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t blockSize=0, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
flatbuffers::FlatBufferBuilder & fbb_
armnnSerializer::NormalizationAlgorithmChannel normChannelType() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
ResizeBilinearDescriptorBuilder Builder
MergerLayerBuilder Builder
flatbuffers::Offset< SerializedGraph > Finish()
void FinishSerializedGraphBuffer(flatbuffers::FlatBufferBuilder &fbb, flatbuffers::Offset< armnnSerializer::SerializedGraph > root)
flatbuffers::Offset< QuantizedLstmLayer > CreateQuantizedLstmLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::QuantizedLstmInputParams > inputParams=0)
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
QLstmLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::Offset< TransposeDescriptor > CreateTransposeDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint32_t > *dimMappings=nullptr)
OriginsDescriptorBuilder Builder
int32_t layerBindingId() const
flatbuffers::Offset< ResizeBilinearDescriptor > Finish()
flatbuffers::Offset< TransposeDescriptor > CreateTransposeDescriptor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> dimMappings=0)
DepthwiseConvolution2dLayerBuilder Builder
void add_numDimensions(uint32_t numDimensions)
flatbuffers::uoffset_t start_
const flatbuffers::Vector< int8_t > * data() const
Pooling2dDescriptorBuilder Builder
TensorInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_hiddenStateZeroPoint(int32_t hiddenStateZeroPoint)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const armnnSerializer::LogSoftmaxLayer * layer_as_LogSoftmaxLayer() const
flatbuffers::FlatBufferBuilder & fbb_
void add_gamma(float gamma)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::FlatBufferBuilder & fbb_
armnnSerializer::ComparisonOperation operation() const
void add_cellIntermediateScale(float cellIntermediateScale)
flatbuffers::uoffset_t start_
LstmInputParamsBuilder Builder
const armnnSerializer::ResizeLayer * layer_as_ResizeLayer() const
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
void add_dimensionality(uint32_t dimensionality)
const armnnSerializer::ComparisonLayer * layer_as_ComparisonLayer() const
SliceLayerBuilder Builder
flatbuffers::Offset< DetectionPostProcessDescriptor > CreateDetectionPostProcessDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t maxDetections=0, uint32_t maxClassesPerDetection=0, uint32_t detectionsPerClass=0, float nmsScoreThreshold=0.0f, float nmsIouThreshold=0.0f, uint32_t numClasses=0, bool useRegularNms=false, float scaleX=0.0f, float scaleY=0.0f, float scaleW=0.0f, float scaleH=0.0f)
flatbuffers::Offset< InstanceNormalizationLayer > Finish()
bool constantWeights() const
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
const OutputShapeRounding(& EnumValuesOutputShapeRounding())[2]
const armnnSerializer::SerializedGraph * GetSerializedGraph(const void *buf)
const char *const * EnumNamesLayerType()
void add_data(flatbuffers::Offset< flatbuffers::Vector< int64_t >> data)
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::LogicalBinaryDescriptor * descriptor() const
flatbuffers::Offset< AnyLayer > CreateAnyLayer(flatbuffers::FlatBufferBuilder &_fbb, armnnSerializer::Layer layer_type=armnnSerializer::Layer_NONE, flatbuffers::Offset< void > layer=0)
GatherDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
MeanLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< OutputLayer > Finish()
flatbuffers::Offset< DepthwiseConvolution2dLayer > CreateDepthwiseConvolution2dLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::DepthwiseConvolution2dDescriptor > descriptor=0, flatbuffers::Offset< armnnSerializer::ConstTensor > weights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > biases=0)
const char * EnumNameLayer(Layer e)
flatbuffers::Offset< MergeLayer > CreateMergeLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
flatbuffers::Offset< SliceLayer > Finish()
const armnnSerializer::FloorLayer * layer_as_FloorLayer() const
BatchNormalizationDescriptorBuilder Builder
L2NormalizationDescriptorBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
StackDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::MultiplicationLayer * layer_as_MultiplicationLayer() const
StridedSliceLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::TensorInfo * info() const
const armnnSerializer::SoftmaxDescriptor * descriptor() const
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
EqualLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
ReduceLayerBuilder Builder
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
ResizeDescriptorBuilder Builder
void add_activationFunction(armnnSerializer::ActivationFunction activationFunction)
flatbuffers::Offset< SoftmaxLayer > Finish()
const flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::OutputSlot > > * outputSlots() const
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< FullyConnectedDescriptor > CreateFullyConnectedDescriptor(flatbuffers::FlatBufferBuilder &_fbb, bool biasEnabled=false, bool transposeWeightsMatrix=false, bool constantWeights=true)
flatbuffers::Offset< ElementwiseUnaryLayer > Finish()
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< ComparisonLayer > Finish()
flatbuffers::Offset< TransposeConvolution2dLayer > CreateTransposeConvolution2dLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::TransposeConvolution2dDescriptor > descriptor=0, flatbuffers::Offset< armnnSerializer::ConstTensor > weights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > biases=0)
flatbuffers::Offset< MinimumLayer > Finish()
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
void add_index(uint32_t index)
const armnnSerializer::ActivationLayer * layer_as_ActivationLayer() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const armnnSerializer::DequantizeLayer * layer_as_DequantizeLayer() const
Pooling2dDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
void add_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
CastLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::ConstTensor * projectionWeights() const
FillDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< LstmInputParams > CreateLstmInputParams(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToForgetWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToCellWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToOutputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToForgetWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToCellWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToOutputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > forgetGateBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > outputGateBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToInputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToInputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellToInputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputGateBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > projectionWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > projectionBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellToForgetWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellToOutputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputLayerNormWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > forgetLayerNormWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellLayerNormWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > outputLayerNormWeights=0)
const void * layer() const
const LogicalBinaryOperation(& EnumValuesLogicalBinaryOperation())[2]
const flatbuffers::Vector< int32_t > * stride() const
flatbuffers::uoffset_t start_
const ResizeMethod(& EnumValuesResizeMethod())[2]
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
PermuteDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< CastLayer > CreateCastLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
flatbuffers::uoffset_t start_
void add_variance(flatbuffers::Offset< armnnSerializer::ConstTensor > variance)
flatbuffers::Offset< LayerBase > CreateLayerBase(flatbuffers::FlatBufferBuilder &_fbb, uint32_t index=0, flatbuffers::Offset< flatbuffers::String > layerName=0, armnnSerializer::LayerType layerType=armnnSerializer::LayerType_Addition, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::InputSlot >>> inputSlots=0, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::OutputSlot >>> outputSlots=0)
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 armnnSerializer::StandInDescriptor * descriptor() const
VT_TRANSPOSEWEIGHTSMATRIX
AbsLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
SplitterLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_base(flatbuffers::Offset< armnnSerializer::BindableLayerBase > base)
const flatbuffers::Vector< float > * quantizationScales() const
flatbuffers::Offset< ByteData > CreateByteDataDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< int8_t > *data=nullptr)
const armnnSerializer::EqualLayer * layer_as_EqualLayer() const
DepthwiseConvolution2dDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< InstanceNormalizationDescriptor > CreateInstanceNormalizationDescriptor(flatbuffers::FlatBufferBuilder &_fbb, float gamma=0.0f, float beta=0.0f, float eps=0.0f, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
void add_dimensions(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> dimensions)
ActivationDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const char *const * EnumNamesPoolingAlgorithm()
AnyLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::OriginsDescriptor * descriptor() const
const armnnSerializer::ShortData * data_as_ShortData() const
BindableLayerBaseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::AbsLayer * layer_as_AbsLayer() const
void add_targetWidth(uint32_t targetWidth)
flatbuffers::uoffset_t start_
flatbuffers::Offset< ArgMinMaxLayer > Finish()
flatbuffers::Offset< MeanDescriptor > Finish()
const armnnSerializer::TransposeConvolution2dDescriptor * descriptor() const
float inputIntermediateScale() const
const armnnSerializer::ConstTensor * inputToCellWeights() const
L2NormalizationDescriptor Table
const flatbuffers::Vector< int32_t > * data() const
ReduceLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::MergeLayer * layer_as_MergeLayer() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
VT_INPUTINTERMEDIATESCALE
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
const armnnSerializer::ViewsDescriptor * descriptor() const
const LayerType(& EnumValuesLayerType())[62]
void add_layer_type(armnnSerializer::Layer layer_type)
StackLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::uoffset_t start_
LogSoftmaxLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
void add_targetHeight(uint32_t targetHeight)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< IntData > CreateIntData(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< int32_t >> data=0)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const armnnSerializer::SliceDescriptor * descriptor() const
ElementwiseUnaryLayer Table
void add_targetShape(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> targetShape)
flatbuffers::Offset< ArgMinMaxDescriptor > Finish()
void add_hiddenStateScale(float hiddenStateScale)
void add_layer(flatbuffers::Offset< void > layer)
StandInLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< ConcatLayer > Finish()
flatbuffers::uoffset_t start_
flatbuffers::Offset< ResizeLayer > CreateResizeLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ResizeDescriptor > descriptor=0)
armnnSerializer::PoolingAlgorithm poolType() const
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
int32_t newAxisMask() const
void add_paddingMethod(armnnSerializer::PaddingMethod paddingMethod)
flatbuffers::uoffset_t start_
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::Offset< FullyConnectedLayer > CreateFullyConnectedLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::FullyConnectedDescriptor > descriptor=0, flatbuffers::Offset< armnnSerializer::ConstTensor > weights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > biases=0)
flatbuffers::Offset< Convolution2dLayer > Finish()
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
const NormalizationAlgorithmChannel(& EnumValuesNormalizationAlgorithmChannel())[2]
const char * EnumNameLogicalBinaryOperation(LogicalBinaryOperation e)
GatherLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
ComparisonLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
flatbuffers::Offset< DequantizeLayer > CreateDequantizeLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
BatchToSpaceNdDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
StackLayerBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< ResizeBilinearLayer > CreateResizeBilinearLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ResizeBilinearDescriptor > descriptor=0)
flatbuffers::Offset< InstanceNormalizationDescriptor > Finish()
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< PadLayer > Finish()
void add_layerType(armnnSerializer::LayerType layerType)
flatbuffers::uoffset_t start_
float forgetIntermediateScale() const
void add_tensorInfo(flatbuffers::Offset< armnnSerializer::TensorInfo > tensorInfo)
flatbuffers::uoffset_t start_
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_weights(flatbuffers::Offset< armnnSerializer::ConstTensor > weights)
void FinishSizePrefixedSerializedGraphBuffer(flatbuffers::FlatBufferBuilder &fbb, flatbuffers::Offset< armnnSerializer::SerializedGraph > root)
DepthToSpaceDescriptorBuilder Builder
QuantizeLayerBuilder Builder
flatbuffers::Offset< ViewsDescriptor > CreateViewsDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::OriginsDescriptor > origins=0, const std::vector< flatbuffers::Offset< armnnSerializer::UintVector >> *viewSizes=nullptr)
void add_dilationX(uint32_t dilationX)
flatbuffers::FlatBufferBuilder & fbb_
Pooling2dLayerBuilder Builder
flatbuffers::Offset< PadDescriptor > Finish()
flatbuffers::Offset< OutputSlot > Finish()
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
BatchToSpaceNdDescriptorBuilder Builder
flatbuffers::Offset< OriginsDescriptor > CreateOriginsDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, uint32_t concatAxis=0, uint32_t numViews=0, uint32_t numDimensions=0, const std::vector< flatbuffers::Offset< armnnSerializer::UintVector >> *viewOrigins=nullptr)
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
const char * EnumNameDataType(DataType e)
DetectionPostProcessDescriptor Table
const char * EnumNamePaddingMethod(PaddingMethod e)
flatbuffers::FlatBufferBuilder & fbb_
void add_featureVersions(flatbuffers::Offset< armnnSerializer::FeatureCompatibilityVersions > featureVersions)
flatbuffers::Offset< DetectionPostProcessLayer > CreateDetectionPostProcessLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::DetectionPostProcessDescriptor > descriptor=0, flatbuffers::Offset< armnnSerializer::ConstTensor > anchors=0)
const flatbuffers::Vector< int64_t > * data() const
void add_data(flatbuffers::Offset< flatbuffers::Vector< int16_t >> data)
MeanDescriptorBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
PadDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< StridedSliceDescriptor > CreateStridedSliceDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< int32_t > *begin=nullptr, const std::vector< int32_t > *end=nullptr, const std::vector< int32_t > *stride=nullptr, int32_t beginMask=0, int32_t endMask=0, int32_t shrinkAxisMask=0, int32_t ellipsisMask=0, int32_t newAxisMask=0, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
flatbuffers::Offset< Pooling2dDescriptor > Finish()
flatbuffers::uoffset_t start_
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)