8 #ifndef FLATBUFFERS_GENERATED_ARMNNSCHEMA_ARMNNSERIALIZER_H_ 9 #define FLATBUFFERS_GENERATED_ARMNNSCHEMA_ARMNNSERIALIZER_H_ 11 #include "flatbuffers/flatbuffers.h" 16 struct TensorInfoBuilder;
21 struct ByteDataBuilder;
24 struct ShortDataBuilder;
27 struct IntDataBuilder;
30 struct LongDataBuilder;
33 struct ConstTensorBuilder;
36 struct InputSlotBuilder;
39 struct OutputSlotBuilder;
42 struct LayerBaseBuilder;
44 struct BindableLayerBase;
45 struct BindableLayerBaseBuilder;
48 struct AbsLayerBuilder;
50 struct ActivationLayer;
51 struct ActivationLayerBuilder;
53 struct ActivationDescriptor;
54 struct ActivationDescriptorBuilder;
57 struct AdditionLayerBuilder;
59 struct ArgMinMaxLayer;
60 struct ArgMinMaxLayerBuilder;
62 struct ArgMinMaxDescriptor;
63 struct ArgMinMaxDescriptorBuilder;
66 struct CastLayerBuilder;
68 struct ChannelShuffleLayer;
69 struct ChannelShuffleLayerBuilder;
71 struct ChannelShuffleDescriptor;
72 struct ChannelShuffleDescriptorBuilder;
74 struct ComparisonDescriptor;
75 struct ComparisonDescriptorBuilder;
77 struct ComparisonLayer;
78 struct ComparisonLayerBuilder;
81 struct ConstantLayerBuilder;
83 struct Convolution2dLayer;
84 struct Convolution2dLayerBuilder;
86 struct Convolution2dDescriptor;
87 struct Convolution2dDescriptorBuilder;
89 struct Convolution3dLayer;
90 struct Convolution3dLayerBuilder;
92 struct Convolution3dDescriptor;
93 struct Convolution3dDescriptorBuilder;
95 struct DepthToSpaceLayer;
96 struct DepthToSpaceLayerBuilder;
99 struct DepthToSpaceDescriptorBuilder;
101 struct DivisionLayer;
102 struct DivisionLayerBuilder;
104 struct ElementwiseUnaryDescriptor;
105 struct ElementwiseUnaryDescriptorBuilder;
107 struct ElementwiseUnaryLayer;
108 struct ElementwiseUnaryLayerBuilder;
111 struct EqualLayerBuilder;
114 struct FillLayerBuilder;
116 struct FillDescriptor;
117 struct FillDescriptorBuilder;
120 struct FloorLayerBuilder;
122 struct FullyConnectedLayer;
123 struct FullyConnectedLayerBuilder;
125 struct FullyConnectedDescriptor;
126 struct FullyConnectedDescriptorBuilder;
129 struct GatherLayerBuilder;
131 struct GatherDescriptor;
132 struct GatherDescriptorBuilder;
134 struct GatherNdLayer;
135 struct GatherNdLayerBuilder;
138 struct GreaterLayerBuilder;
141 struct InputLayerBuilder;
143 struct InstanceNormalizationLayer;
144 struct InstanceNormalizationLayerBuilder;
146 struct InstanceNormalizationDescriptor;
147 struct InstanceNormalizationDescriptorBuilder;
149 struct LogSoftmaxLayer;
150 struct LogSoftmaxLayerBuilder;
153 struct LogSoftmaxDescriptorBuilder;
155 struct L2NormalizationLayer;
156 struct L2NormalizationLayerBuilder;
158 struct L2NormalizationDescriptor;
159 struct L2NormalizationDescriptorBuilder;
161 struct LogicalBinaryDescriptor;
162 struct LogicalBinaryDescriptorBuilder;
164 struct LogicalBinaryLayer;
165 struct LogicalBinaryLayerBuilder;
168 struct MinimumLayerBuilder;
171 struct MaximumLayerBuilder;
173 struct MultiplicationLayer;
174 struct MultiplicationLayerBuilder;
176 struct Pooling2dLayer;
177 struct Pooling2dLayerBuilder;
179 struct Pooling3dLayer;
180 struct Pooling3dLayerBuilder;
183 struct Pooling2dDescriptorBuilder;
186 struct Pooling3dDescriptorBuilder;
188 struct QuantizeLayer;
189 struct QuantizeLayerBuilder;
192 struct SoftmaxLayerBuilder;
194 struct SoftmaxDescriptor;
195 struct SoftmaxDescriptorBuilder;
197 struct DepthwiseConvolution2dLayer;
198 struct DepthwiseConvolution2dLayerBuilder;
200 struct DepthwiseConvolution2dDescriptor;
201 struct DepthwiseConvolution2dDescriptorBuilder;
204 struct OutputLayerBuilder;
207 struct ReshapeLayerBuilder;
209 struct ReshapeDescriptor;
210 struct ReshapeDescriptorBuilder;
213 struct PermuteLayerBuilder;
215 struct PermuteDescriptor;
216 struct PermuteDescriptorBuilder;
219 struct ShapeLayerBuilder;
221 struct SpaceToBatchNdLayer;
222 struct SpaceToBatchNdLayerBuilder;
224 struct SpaceToBatchNdDescriptor;
225 struct SpaceToBatchNdDescriptorBuilder;
227 struct SpaceToDepthLayer;
228 struct SpaceToDepthLayerBuilder;
230 struct SpaceToDepthDescriptor;
231 struct SpaceToDepthDescriptorBuilder;
233 struct SubtractionLayer;
234 struct SubtractionLayerBuilder;
236 struct BatchToSpaceNdLayer;
237 struct BatchToSpaceNdLayerBuilder;
239 struct BatchToSpaceNdDescriptor;
240 struct BatchToSpaceNdDescriptorBuilder;
242 struct NormalizationLayer;
243 struct NormalizationLayerBuilder;
245 struct NormalizationDescriptor;
246 struct NormalizationDescriptorBuilder;
249 struct MeanLayerBuilder;
251 struct MeanDescriptor;
252 struct MeanDescriptorBuilder;
255 struct PadLayerBuilder;
257 struct PadDescriptor;
258 struct PadDescriptorBuilder;
261 struct RsqrtLayerBuilder;
263 struct BatchNormalizationLayer;
264 struct BatchNormalizationLayerBuilder;
266 struct BatchNormalizationDescriptor;
267 struct BatchNormalizationDescriptorBuilder;
269 struct ResizeBilinearLayer;
270 struct ResizeBilinearLayerBuilder;
272 struct ResizeBilinearDescriptor;
273 struct ResizeBilinearDescriptorBuilder;
276 struct SliceLayerBuilder;
278 struct SliceDescriptor;
279 struct SliceDescriptorBuilder;
281 struct StridedSliceLayer;
282 struct StridedSliceLayerBuilder;
284 struct StridedSliceDescriptor;
285 struct StridedSliceDescriptorBuilder;
288 struct ConcatLayerBuilder;
291 struct MergerLayerBuilder;
294 struct UintVectorBuilder;
296 struct OriginsDescriptor;
297 struct OriginsDescriptorBuilder;
299 struct ViewsDescriptor;
300 struct ViewsDescriptorBuilder;
302 struct SplitterLayer;
303 struct SplitterLayerBuilder;
305 struct DetectionPostProcessLayer;
306 struct DetectionPostProcessLayerBuilder;
308 struct DetectionPostProcessDescriptor;
309 struct DetectionPostProcessDescriptorBuilder;
311 struct LstmInputParams;
312 struct LstmInputParamsBuilder;
314 struct LstmDescriptor;
315 struct LstmDescriptorBuilder;
318 struct LstmLayerBuilder;
320 struct QLstmInputParams;
321 struct QLstmInputParamsBuilder;
323 struct QLstmDescriptor;
324 struct QLstmDescriptorBuilder;
327 struct QLstmLayerBuilder;
329 struct QuantizedLstmInputParams;
330 struct QuantizedLstmInputParamsBuilder;
332 struct QuantizedLstmLayer;
333 struct QuantizedLstmLayerBuilder;
335 struct DequantizeLayer;
336 struct DequantizeLayerBuilder;
339 struct MergeLayerBuilder;
342 struct SwitchLayerBuilder;
345 struct PreluLayerBuilder;
347 struct TransposeConvolution2dLayer;
348 struct TransposeConvolution2dLayerBuilder;
350 struct TransposeConvolution2dDescriptor;
351 struct TransposeConvolution2dDescriptorBuilder;
353 struct TransposeLayer;
354 struct TransposeLayerBuilder;
356 struct TransposeDescriptor;
357 struct TransposeDescriptorBuilder;
360 struct ResizeLayerBuilder;
362 struct ResizeDescriptor;
363 struct ResizeDescriptorBuilder;
366 struct StackLayerBuilder;
368 struct StackDescriptor;
369 struct StackDescriptorBuilder;
371 struct StandInDescriptor;
372 struct StandInDescriptorBuilder;
375 struct StandInLayerBuilder;
378 struct RankLayerBuilder;
381 struct ReduceLayerBuilder;
383 struct ReduceDescriptor;
384 struct ReduceDescriptorBuilder;
387 struct UnidirectionalSequenceLstmDescriptorBuilder;
389 struct UnidirectionalSequenceLstmLayer;
390 struct UnidirectionalSequenceLstmLayerBuilder;
393 struct AnyLayerBuilder;
395 struct FeatureCompatibilityVersions;
396 struct FeatureCompatibilityVersionsBuilder;
398 struct SerializedGraph;
399 struct SerializedGraphBuilder;
437 static const char *
const names[13] = {
457 const size_t index =
static_cast<size_t>(e);
477 static const char *
const names[3] = {
487 const size_t index =
static_cast<size_t>(e);
525 static const char *
const names[12] = {
544 const size_t index =
static_cast<size_t>(e);
568 static const char *
const names[5] = {
580 const size_t index =
static_cast<size_t>(e);
606 static const char *
const names[6] = {
619 const size_t index =
static_cast<size_t>(e);
639 static const char *
const names[3] = {
649 const size_t index =
static_cast<size_t>(e);
675 static const char *
const names[6] = {
688 const size_t index =
static_cast<size_t>(e);
713 bool VerifyConstTensorDataVector(flatbuffers::Verifier &verifier,
const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
const flatbuffers::Vector<uint8_t> *types);
863 static const char *
const names[69] = {
872 "DepthwiseConvolution2d",
887 "BatchNormalization",
897 "DetectionPostProcess",
906 "TransposeConvolution2d",
914 "InstanceNormalization",
927 "UnidirectionalSequenceLstm",
939 const size_t index =
static_cast<size_t>(e);
967 static const char *
const names[7] = {
981 const size_t index =
static_cast<size_t>(e);
1013 static const char *
const names[9] = {
1029 const size_t index =
static_cast<size_t>(e);
1049 static const char *
const names[3] = {
1059 const size_t index =
static_cast<size_t>(e);
1081 static const char *
const names[4] = {
1092 const size_t index =
static_cast<size_t>(e);
1112 static const char *
const names[3] = {
1122 const size_t index =
static_cast<size_t>(e);
1142 static const char *
const names[3] = {
1152 const size_t index =
static_cast<size_t>(e);
1172 static const char *
const names[3] = {
1182 const size_t index =
static_cast<size_t>(e);
1202 static const char *
const names[3] = {
1212 const size_t index =
static_cast<size_t>(e);
1234 static const char *
const names[4] = {
1245 const size_t index =
static_cast<size_t>(e);
1324 static const Layer values[] = {
1399 static const char *
const names[70] = {
1403 "BatchToSpaceNdLayer",
1404 "BatchNormalizationLayer",
1406 "Convolution2dLayer",
1407 "DepthwiseConvolution2dLayer",
1408 "FullyConnectedLayer",
1410 "MultiplicationLayer",
1416 "SpaceToBatchNdLayer",
1421 "NormalizationLayer",
1426 "ResizeBilinearLayer",
1428 "StridedSliceLayer",
1432 "L2NormalizationLayer",
1434 "DetectionPostProcessLayer",
1436 "QuantizedLstmLayer",
1442 "SpaceToDepthLayer",
1444 "TransposeConvolution2dLayer",
1450 "DepthToSpaceLayer",
1451 "InstanceNormalizationLayer",
1455 "ElementwiseUnaryLayer",
1460 "LogicalBinaryLayer",
1464 "UnidirectionalSequenceLstmLayer",
1465 "ChannelShuffleLayer",
1466 "Convolution3dLayer",
1476 const size_t index =
static_cast<size_t>(e);
1756 bool VerifyLayer(flatbuffers::Verifier &verifier,
const void *obj,
Layer type);
1757 bool VerifyLayerVector(flatbuffers::Verifier &verifier,
const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
const flatbuffers::Vector<uint8_t> *types);
1761 uint32_t sourceLayerIndex_;
1762 uint32_t outputSlotIndex_;
1766 memset(static_cast<void *>(
this), 0,
sizeof(Connection));
1768 Connection(uint32_t _sourceLayerIndex, uint32_t _outputSlotIndex)
1769 : sourceLayerIndex_(flatbuffers::EndianScalar(_sourceLayerIndex)),
1770 outputSlotIndex_(flatbuffers::EndianScalar(_outputSlotIndex)) {
1772 uint32_t sourceLayerIndex()
const {
1773 return flatbuffers::EndianScalar(sourceLayerIndex_);
1775 uint32_t outputSlotIndex()
const {
1776 return flatbuffers::EndianScalar(outputSlotIndex_);
1783 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1795 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_DIMENSIONS);
1819 return GetField<uint8_t>(VT_ISCONSTANT, 0) != 0;
1821 bool Verify(flatbuffers::Verifier &verifier)
const {
1822 return VerifyTableStart(verifier) &&
1824 verifier.VerifyVector(dimensions()) &&
1829 verifier.VerifyVector(quantizationScales()) &&
1833 verifier.VerifyVector(dimensionSpecificity()) &&
1834 VerifyField<uint8_t>(verifier, VT_ISCONSTANT) &&
1835 verifier.EndTable();
1841 flatbuffers::FlatBufferBuilder &
fbb_;
1868 fbb_.AddElement<uint8_t>(TensorInfo::VT_ISCONSTANT,
static_cast<uint8_t
>(isConstant), 0);
1872 start_ = fbb_.StartTable();
1876 const auto end = fbb_.EndTable(start_);
1877 auto o = flatbuffers::Offset<TensorInfo>(end);
1883 flatbuffers::FlatBufferBuilder &_fbb,
1886 float quantizationScale = 1.0f,
1887 int32_t quantizationOffset = 0,
1889 uint32_t quantizationDim = 0,
1890 uint32_t dimensionality = 1,
1892 bool isConstant =
false) {
1903 return builder_.
Finish();
1907 flatbuffers::FlatBufferBuilder &_fbb,
1908 const std::vector<uint32_t> *dimensions =
nullptr,
1910 float quantizationScale = 1.0f,
1911 int32_t quantizationOffset = 0,
1912 const std::vector<float> *quantizationScales =
nullptr,
1913 uint32_t quantizationDim = 0,
1914 uint32_t dimensionality = 1,
1915 const std::vector<uint8_t> *dimensionSpecificity =
nullptr,
1916 bool isConstant =
false) {
1917 auto dimensions__ = dimensions ? _fbb.CreateVector<uint32_t>(*dimensions) : 0;
1918 auto quantizationScales__ = quantizationScales ? _fbb.CreateVector<
float>(*quantizationScales) : 0;
1919 auto dimensionSpecificity__ = dimensionSpecificity ? _fbb.CreateVector<uint8_t>(*dimensionSpecificity) : 0;
1926 quantizationScales__,
1929 dimensionSpecificity__,
1933 struct ByteData FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
1935 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1938 const flatbuffers::Vector<int8_t> *
data()
const {
1939 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_DATA);
1941 bool Verify(flatbuffers::Verifier &verifier)
const {
1942 return VerifyTableStart(verifier) &&
1943 VerifyOffset(verifier, VT_DATA) &&
1944 verifier.VerifyVector(data()) &&
1945 verifier.EndTable();
1951 flatbuffers::FlatBufferBuilder &
fbb_;
1954 fbb_.AddOffset(ByteData::VT_DATA, data);
1958 start_ = fbb_.StartTable();
1962 const auto end = fbb_.EndTable(start_);
1963 auto o = flatbuffers::Offset<ByteData>(end);
1969 flatbuffers::FlatBufferBuilder &_fbb,
1973 return builder_.
Finish();
1977 flatbuffers::FlatBufferBuilder &_fbb,
1978 const std::vector<int8_t> *data =
nullptr) {
1979 auto data__ = data ? _fbb.CreateVector<int8_t>(*data) : 0;
1985 struct ShortData FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
1987 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1990 const flatbuffers::Vector<int16_t> *
data()
const {
1991 return GetPointer<const flatbuffers::Vector<int16_t> *>(VT_DATA);
1993 bool Verify(flatbuffers::Verifier &verifier)
const {
1994 return VerifyTableStart(verifier) &&
1995 VerifyOffset(verifier, VT_DATA) &&
1996 verifier.VerifyVector(data()) &&
1997 verifier.EndTable();
2003 flatbuffers::FlatBufferBuilder &
fbb_;
2006 fbb_.AddOffset(ShortData::VT_DATA, data);
2010 start_ = fbb_.StartTable();
2014 const auto end = fbb_.EndTable(start_);
2015 auto o = flatbuffers::Offset<ShortData>(end);
2021 flatbuffers::FlatBufferBuilder &_fbb,
2025 return builder_.
Finish();
2029 flatbuffers::FlatBufferBuilder &_fbb,
2030 const std::vector<int16_t> *data =
nullptr) {
2031 auto data__ = data ? _fbb.CreateVector<int16_t>(*data) : 0;
2037 struct IntData FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2039 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2042 const flatbuffers::Vector<int32_t> *
data()
const {
2043 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_DATA);
2045 bool Verify(flatbuffers::Verifier &verifier)
const {
2046 return VerifyTableStart(verifier) &&
2047 VerifyOffset(verifier, VT_DATA) &&
2048 verifier.VerifyVector(data()) &&
2049 verifier.EndTable();
2055 flatbuffers::FlatBufferBuilder &
fbb_;
2058 fbb_.AddOffset(IntData::VT_DATA, data);
2062 start_ = fbb_.StartTable();
2066 const auto end = fbb_.EndTable(start_);
2067 auto o = flatbuffers::Offset<IntData>(end);
2073 flatbuffers::FlatBufferBuilder &_fbb,
2077 return builder_.
Finish();
2081 flatbuffers::FlatBufferBuilder &_fbb,
2082 const std::vector<int32_t> *data =
nullptr) {
2083 auto data__ = data ? _fbb.CreateVector<int32_t>(*data) : 0;
2089 struct LongData FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2091 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2094 const flatbuffers::Vector<int64_t> *
data()
const {
2095 return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_DATA);
2097 bool Verify(flatbuffers::Verifier &verifier)
const {
2098 return VerifyTableStart(verifier) &&
2099 VerifyOffset(verifier, VT_DATA) &&
2100 verifier.VerifyVector(data()) &&
2101 verifier.EndTable();
2107 flatbuffers::FlatBufferBuilder &
fbb_;
2110 fbb_.AddOffset(LongData::VT_DATA, data);
2114 start_ = fbb_.StartTable();
2118 const auto end = fbb_.EndTable(start_);
2119 auto o = flatbuffers::Offset<LongData>(end);
2125 flatbuffers::FlatBufferBuilder &_fbb,
2129 return builder_.
Finish();
2133 flatbuffers::FlatBufferBuilder &_fbb,
2134 const std::vector<int64_t> *data =
nullptr) {
2135 auto data__ = data ? _fbb.CreateVector<int64_t>(*data) : 0;
2141 struct ConstTensor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2143 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2148 const armnnSerializer::TensorInfo *
info()
const {
2149 return GetPointer<const armnnSerializer::TensorInfo *>(
VT_INFO);
2155 return GetPointer<const void *>(VT_DATA);
2157 template<
typename T>
const T *data_as()
const;
2170 bool Verify(flatbuffers::Verifier &verifier)
const {
2171 return VerifyTableStart(verifier) &&
2172 VerifyOffset(verifier,
VT_INFO) &&
2173 verifier.VerifyTable(info()) &&
2175 VerifyOffset(verifier, VT_DATA) &&
2177 verifier.EndTable();
2181 template<>
inline const armnnSerializer::ByteData *ConstTensor::data_as<armnnSerializer::ByteData>()
const {
2182 return data_as_ByteData();
2185 template<>
inline const armnnSerializer::ShortData *ConstTensor::data_as<armnnSerializer::ShortData>()
const {
2186 return data_as_ShortData();
2189 template<>
inline const armnnSerializer::IntData *ConstTensor::data_as<armnnSerializer::IntData>()
const {
2190 return data_as_IntData();
2193 template<>
inline const armnnSerializer::LongData *ConstTensor::data_as<armnnSerializer::LongData>()
const {
2194 return data_as_LongData();
2199 flatbuffers::FlatBufferBuilder &
fbb_;
2201 void add_info(flatbuffers::Offset<armnnSerializer::TensorInfo> info) {
2208 fbb_.AddOffset(ConstTensor::VT_DATA, data);
2212 start_ = fbb_.StartTable();
2216 const auto end = fbb_.EndTable(start_);
2217 auto o = flatbuffers::Offset<ConstTensor>(end);
2223 flatbuffers::FlatBufferBuilder &_fbb,
2224 flatbuffers::Offset<armnnSerializer::TensorInfo> info = 0,
2226 flatbuffers::Offset<void> data = 0) {
2231 return builder_.
Finish();
2234 struct InputSlot FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2236 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2241 return GetField<uint32_t>(
VT_INDEX, 0);
2244 return GetStruct<const armnnSerializer::Connection *>(VT_CONNECTION);
2246 bool Verify(flatbuffers::Verifier &verifier)
const {
2247 return VerifyTableStart(verifier) &&
2248 VerifyField<uint32_t>(verifier,
VT_INDEX) &&
2249 VerifyField<armnnSerializer::Connection>(verifier, VT_CONNECTION) &&
2250 verifier.EndTable();
2256 flatbuffers::FlatBufferBuilder &
fbb_;
2262 fbb_.AddStruct(InputSlot::VT_CONNECTION, connection);
2266 start_ = fbb_.StartTable();
2270 const auto end = fbb_.EndTable(start_);
2271 auto o = flatbuffers::Offset<InputSlot>(end);
2277 flatbuffers::FlatBufferBuilder &_fbb,
2279 const armnnSerializer::Connection *connection = 0) {
2283 return builder_.
Finish();
2286 struct OutputSlot FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2288 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2293 return GetField<uint32_t>(
VT_INDEX, 0);
2296 return GetPointer<const armnnSerializer::TensorInfo *>(VT_TENSORINFO);
2298 bool Verify(flatbuffers::Verifier &verifier)
const {
2299 return VerifyTableStart(verifier) &&
2300 VerifyField<uint32_t>(verifier,
VT_INDEX) &&
2301 VerifyOffset(verifier, VT_TENSORINFO) &&
2302 verifier.VerifyTable(tensorInfo()) &&
2303 verifier.EndTable();
2309 flatbuffers::FlatBufferBuilder &
fbb_;
2315 fbb_.AddOffset(OutputSlot::VT_TENSORINFO, tensorInfo);
2319 start_ = fbb_.StartTable();
2323 const auto end = fbb_.EndTable(start_);
2324 auto o = flatbuffers::Offset<OutputSlot>(end);
2330 flatbuffers::FlatBufferBuilder &_fbb,
2332 flatbuffers::Offset<armnnSerializer::TensorInfo> tensorInfo = 0) {
2336 return builder_.
Finish();
2339 struct LayerBase FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2341 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2349 return GetField<uint32_t>(
VT_INDEX, 0);
2352 return GetPointer<const flatbuffers::String *>(
VT_LAYERNAME);
2357 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::InputSlot>> *
inputSlots()
const {
2358 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::InputSlot>> *>(
VT_INPUTSLOTS);
2360 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::OutputSlot>> *
outputSlots()
const {
2361 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::OutputSlot>> *>(VT_OUTPUTSLOTS);
2363 bool Verify(flatbuffers::Verifier &verifier)
const {
2364 return VerifyTableStart(verifier) &&
2365 VerifyField<uint32_t>(verifier,
VT_INDEX) &&
2367 verifier.VerifyString(layerName()) &&
2370 verifier.VerifyVector(inputSlots()) &&
2371 verifier.VerifyVectorOfTables(inputSlots()) &&
2372 VerifyOffset(verifier, VT_OUTPUTSLOTS) &&
2373 verifier.VerifyVector(outputSlots()) &&
2374 verifier.VerifyVectorOfTables(outputSlots()) &&
2375 verifier.EndTable();
2381 flatbuffers::FlatBufferBuilder &
fbb_;
2396 fbb_.AddOffset(LayerBase::VT_OUTPUTSLOTS, outputSlots);
2400 start_ = fbb_.StartTable();
2404 const auto end = fbb_.EndTable(start_);
2405 auto o = flatbuffers::Offset<LayerBase>(end);
2411 flatbuffers::FlatBufferBuilder &_fbb,
2413 flatbuffers::Offset<flatbuffers::String> layerName = 0,
2415 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::InputSlot>>> inputSlots = 0,
2416 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::OutputSlot>>> outputSlots = 0) {
2423 return builder_.
Finish();
2427 flatbuffers::FlatBufferBuilder &_fbb,
2429 const char *layerName =
nullptr,
2431 const std::vector<flatbuffers::Offset<armnnSerializer::InputSlot>> *inputSlots =
nullptr,
2432 const std::vector<flatbuffers::Offset<armnnSerializer::OutputSlot>> *outputSlots =
nullptr) {
2433 auto layerName__ = layerName ? _fbb.CreateString(layerName) : 0;
2434 auto inputSlots__ = inputSlots ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::InputSlot>>(*inputSlots) : 0;
2435 auto outputSlots__ = outputSlots ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::OutputSlot>>(*outputSlots) : 0;
2445 struct BindableLayerBase FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2447 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2449 VT_LAYERBINDINGID = 6
2451 const armnnSerializer::LayerBase *
base()
const {
2452 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2455 return GetField<int32_t>(VT_LAYERBINDINGID, 0);
2457 bool Verify(flatbuffers::Verifier &verifier)
const {
2458 return VerifyTableStart(verifier) &&
2459 VerifyOffset(verifier,
VT_BASE) &&
2460 verifier.VerifyTable(base()) &&
2461 VerifyField<int32_t>(verifier, VT_LAYERBINDINGID) &&
2462 verifier.EndTable();
2468 flatbuffers::FlatBufferBuilder &
fbb_;
2470 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2474 fbb_.AddElement<int32_t>(BindableLayerBase::VT_LAYERBINDINGID, layerBindingId, 0);
2478 start_ = fbb_.StartTable();
2481 flatbuffers::Offset<BindableLayerBase>
Finish() {
2482 const auto end = fbb_.EndTable(start_);
2483 auto o = flatbuffers::Offset<BindableLayerBase>(end);
2489 flatbuffers::FlatBufferBuilder &_fbb,
2490 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2491 int32_t layerBindingId = 0) {
2495 return builder_.
Finish();
2499 struct AbsLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2501 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2504 const armnnSerializer::LayerBase *
base()
const {
2505 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2507 bool Verify(flatbuffers::Verifier &verifier)
const {
2508 return VerifyTableStart(verifier) &&
2509 VerifyOffset(verifier,
VT_BASE) &&
2510 verifier.VerifyTable(base()) &&
2511 verifier.EndTable();
2517 flatbuffers::FlatBufferBuilder &
fbb_;
2519 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2524 start_ = fbb_.StartTable();
2528 const auto end = fbb_.EndTable(start_);
2529 auto o = flatbuffers::Offset<AbsLayer>(end);
2535 flatbuffers::FlatBufferBuilder &_fbb,
2536 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
2539 return builder_.
Finish();
2542 struct ActivationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2544 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2548 const armnnSerializer::LayerBase *
base()
const {
2549 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2551 const armnnSerializer::ActivationDescriptor *
descriptor()
const {
2552 return GetPointer<const armnnSerializer::ActivationDescriptor *>(
VT_DESCRIPTOR);
2554 bool Verify(flatbuffers::Verifier &verifier)
const {
2555 return VerifyTableStart(verifier) &&
2556 VerifyOffset(verifier,
VT_BASE) &&
2557 verifier.VerifyTable(base()) &&
2559 verifier.VerifyTable(descriptor()) &&
2560 verifier.EndTable();
2566 flatbuffers::FlatBufferBuilder &
fbb_;
2568 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2571 void add_descriptor(flatbuffers::Offset<armnnSerializer::ActivationDescriptor> descriptor) {
2576 start_ = fbb_.StartTable();
2579 flatbuffers::Offset<ActivationLayer>
Finish() {
2580 const auto end = fbb_.EndTable(start_);
2581 auto o = flatbuffers::Offset<ActivationLayer>(end);
2587 flatbuffers::FlatBufferBuilder &_fbb,
2588 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2589 flatbuffers::Offset<armnnSerializer::ActivationDescriptor> descriptor = 0) {
2593 return builder_.
Finish();
2596 struct ActivationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2598 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2607 return GetField<float>(
VT_A, 0.0f);
2610 return GetField<float>(VT_B, 0.0f);
2612 bool Verify(flatbuffers::Verifier &verifier)
const {
2613 return VerifyTableStart(verifier) &&
2615 VerifyField<float>(verifier,
VT_A) &&
2616 VerifyField<float>(verifier, VT_B) &&
2617 verifier.EndTable();
2623 flatbuffers::FlatBufferBuilder &
fbb_;
2632 fbb_.AddElement<
float>(ActivationDescriptor::VT_B, b, 0.0f);
2636 start_ = fbb_.StartTable();
2639 flatbuffers::Offset<ActivationDescriptor>
Finish() {
2640 const auto end = fbb_.EndTable(start_);
2641 auto o = flatbuffers::Offset<ActivationDescriptor>(end);
2647 flatbuffers::FlatBufferBuilder &_fbb,
2655 return builder_.
Finish();
2658 struct AdditionLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2660 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2663 const armnnSerializer::LayerBase *
base()
const {
2664 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2666 bool Verify(flatbuffers::Verifier &verifier)
const {
2667 return VerifyTableStart(verifier) &&
2668 VerifyOffset(verifier,
VT_BASE) &&
2669 verifier.VerifyTable(base()) &&
2670 verifier.EndTable();
2676 flatbuffers::FlatBufferBuilder &
fbb_;
2678 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2683 start_ = fbb_.StartTable();
2686 flatbuffers::Offset<AdditionLayer>
Finish() {
2687 const auto end = fbb_.EndTable(start_);
2688 auto o = flatbuffers::Offset<AdditionLayer>(end);
2694 flatbuffers::FlatBufferBuilder &_fbb,
2695 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
2698 return builder_.
Finish();
2701 struct ArgMinMaxLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2703 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2707 const armnnSerializer::LayerBase *
base()
const {
2708 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2711 return GetPointer<const armnnSerializer::ArgMinMaxDescriptor *>(
VT_DESCRIPTOR);
2713 bool Verify(flatbuffers::Verifier &verifier)
const {
2714 return VerifyTableStart(verifier) &&
2715 VerifyOffset(verifier,
VT_BASE) &&
2716 verifier.VerifyTable(base()) &&
2718 verifier.VerifyTable(descriptor()) &&
2719 verifier.EndTable();
2725 flatbuffers::FlatBufferBuilder &
fbb_;
2727 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2730 void add_descriptor(flatbuffers::Offset<armnnSerializer::ArgMinMaxDescriptor> descriptor) {
2735 start_ = fbb_.StartTable();
2738 flatbuffers::Offset<ArgMinMaxLayer>
Finish() {
2739 const auto end = fbb_.EndTable(start_);
2740 auto o = flatbuffers::Offset<ArgMinMaxLayer>(end);
2746 flatbuffers::FlatBufferBuilder &_fbb,
2747 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2748 flatbuffers::Offset<armnnSerializer::ArgMinMaxDescriptor> descriptor = 0) {
2752 return builder_.
Finish();
2755 struct ArgMinMaxDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2757 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2765 return GetField<int32_t>(
VT_AXIS, 0);
2767 bool Verify(flatbuffers::Verifier &verifier)
const {
2768 return VerifyTableStart(verifier) &&
2770 VerifyField<int32_t>(verifier,
VT_AXIS) &&
2771 verifier.EndTable();
2777 flatbuffers::FlatBufferBuilder &
fbb_;
2787 start_ = fbb_.StartTable();
2790 flatbuffers::Offset<ArgMinMaxDescriptor>
Finish() {
2791 const auto end = fbb_.EndTable(start_);
2792 auto o = flatbuffers::Offset<ArgMinMaxDescriptor>(end);
2798 flatbuffers::FlatBufferBuilder &_fbb,
2804 return builder_.
Finish();
2807 struct CastLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2809 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2812 const armnnSerializer::LayerBase *
base()
const {
2813 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2815 bool Verify(flatbuffers::Verifier &verifier)
const {
2816 return VerifyTableStart(verifier) &&
2817 VerifyOffset(verifier,
VT_BASE) &&
2818 verifier.VerifyTable(base()) &&
2819 verifier.EndTable();
2825 flatbuffers::FlatBufferBuilder &
fbb_;
2827 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2832 start_ = fbb_.StartTable();
2836 const auto end = fbb_.EndTable(start_);
2837 auto o = flatbuffers::Offset<CastLayer>(end);
2843 flatbuffers::FlatBufferBuilder &_fbb,
2844 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
2847 return builder_.
Finish();
2850 struct ChannelShuffleLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2852 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2856 const armnnSerializer::LayerBase *
base()
const {
2857 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
2859 const armnnSerializer::ChannelShuffleDescriptor *
descriptor()
const {
2860 return GetPointer<const armnnSerializer::ChannelShuffleDescriptor *>(
VT_DESCRIPTOR);
2862 bool Verify(flatbuffers::Verifier &verifier)
const {
2863 return VerifyTableStart(verifier) &&
2864 VerifyOffset(verifier,
VT_BASE) &&
2865 verifier.VerifyTable(base()) &&
2867 verifier.VerifyTable(descriptor()) &&
2868 verifier.EndTable();
2874 flatbuffers::FlatBufferBuilder &
fbb_;
2876 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
2879 void add_descriptor(flatbuffers::Offset<armnnSerializer::ChannelShuffleDescriptor> descriptor) {
2884 start_ = fbb_.StartTable();
2887 flatbuffers::Offset<ChannelShuffleLayer>
Finish() {
2888 const auto end = fbb_.EndTable(start_);
2889 auto o = flatbuffers::Offset<ChannelShuffleLayer>(end);
2895 flatbuffers::FlatBufferBuilder &_fbb,
2896 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
2897 flatbuffers::Offset<armnnSerializer::ChannelShuffleDescriptor> descriptor = 0) {
2901 return builder_.
Finish();
2904 struct ChannelShuffleDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2906 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2911 return GetField<uint32_t>(
VT_AXIS, 0);
2914 return GetField<uint32_t>(VT_NUMGROUPS, 0);
2916 bool Verify(flatbuffers::Verifier &verifier)
const {
2917 return VerifyTableStart(verifier) &&
2918 VerifyField<uint32_t>(verifier,
VT_AXIS) &&
2919 VerifyField<uint32_t>(verifier, VT_NUMGROUPS) &&
2920 verifier.EndTable();
2926 flatbuffers::FlatBufferBuilder &
fbb_;
2932 fbb_.AddElement<uint32_t>(ChannelShuffleDescriptor::VT_NUMGROUPS, numGroups, 0);
2936 start_ = fbb_.StartTable();
2939 flatbuffers::Offset<ChannelShuffleDescriptor>
Finish() {
2940 const auto end = fbb_.EndTable(start_);
2941 auto o = flatbuffers::Offset<ChannelShuffleDescriptor>(end);
2947 flatbuffers::FlatBufferBuilder &_fbb,
2949 uint32_t numGroups = 0) {
2953 return builder_.
Finish();
2956 struct ComparisonDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
2958 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2964 bool Verify(flatbuffers::Verifier &verifier)
const {
2965 return VerifyTableStart(verifier) &&
2966 VerifyField<int8_t>(verifier, VT_OPERATION) &&
2967 verifier.EndTable();
2973 flatbuffers::FlatBufferBuilder &
fbb_;
2976 fbb_.AddElement<int8_t>(ComparisonDescriptor::VT_OPERATION,
static_cast<int8_t
>(operation), 0);
2980 start_ = fbb_.StartTable();
2983 flatbuffers::Offset<ComparisonDescriptor>
Finish() {
2984 const auto end = fbb_.EndTable(start_);
2985 auto o = flatbuffers::Offset<ComparisonDescriptor>(end);
2991 flatbuffers::FlatBufferBuilder &_fbb,
2995 return builder_.
Finish();
2998 struct ComparisonLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3000 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3004 const armnnSerializer::LayerBase *
base()
const {
3005 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3007 const armnnSerializer::ComparisonDescriptor *
descriptor()
const {
3008 return GetPointer<const armnnSerializer::ComparisonDescriptor *>(
VT_DESCRIPTOR);
3010 bool Verify(flatbuffers::Verifier &verifier)
const {
3011 return VerifyTableStart(verifier) &&
3012 VerifyOffset(verifier,
VT_BASE) &&
3013 verifier.VerifyTable(base()) &&
3015 verifier.VerifyTable(descriptor()) &&
3016 verifier.EndTable();
3022 flatbuffers::FlatBufferBuilder &
fbb_;
3024 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3027 void add_descriptor(flatbuffers::Offset<armnnSerializer::ComparisonDescriptor> descriptor) {
3032 start_ = fbb_.StartTable();
3035 flatbuffers::Offset<ComparisonLayer>
Finish() {
3036 const auto end = fbb_.EndTable(start_);
3037 auto o = flatbuffers::Offset<ComparisonLayer>(end);
3043 flatbuffers::FlatBufferBuilder &_fbb,
3044 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3045 flatbuffers::Offset<armnnSerializer::ComparisonDescriptor> descriptor = 0) {
3049 return builder_.
Finish();
3052 struct ConstantLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3054 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3058 const armnnSerializer::LayerBase *
base()
const {
3059 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3061 const armnnSerializer::ConstTensor *
input()
const {
3062 return GetPointer<const armnnSerializer::ConstTensor *>(VT_INPUT);
3064 bool Verify(flatbuffers::Verifier &verifier)
const {
3065 return VerifyTableStart(verifier) &&
3066 VerifyOffset(verifier,
VT_BASE) &&
3067 verifier.VerifyTable(base()) &&
3068 VerifyOffset(verifier, VT_INPUT) &&
3069 verifier.VerifyTable(input()) &&
3070 verifier.EndTable();
3076 flatbuffers::FlatBufferBuilder &
fbb_;
3078 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3081 void add_input(flatbuffers::Offset<armnnSerializer::ConstTensor> input) {
3082 fbb_.AddOffset(ConstantLayer::VT_INPUT, input);
3086 start_ = fbb_.StartTable();
3089 flatbuffers::Offset<ConstantLayer>
Finish() {
3090 const auto end = fbb_.EndTable(start_);
3091 auto o = flatbuffers::Offset<ConstantLayer>(end);
3097 flatbuffers::FlatBufferBuilder &_fbb,
3098 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3099 flatbuffers::Offset<armnnSerializer::ConstTensor> input = 0) {
3103 return builder_.
Finish();
3106 struct Convolution2dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3108 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3114 const armnnSerializer::LayerBase *
base()
const {
3115 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3117 const armnnSerializer::Convolution2dDescriptor *
descriptor()
const {
3118 return GetPointer<const armnnSerializer::Convolution2dDescriptor *>(
VT_DESCRIPTOR);
3120 const armnnSerializer::ConstTensor *
weights()
const {
3121 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_WEIGHTS);
3123 const armnnSerializer::ConstTensor *
biases()
const {
3124 return GetPointer<const armnnSerializer::ConstTensor *>(VT_BIASES);
3126 bool Verify(flatbuffers::Verifier &verifier)
const {
3127 return VerifyTableStart(verifier) &&
3128 VerifyOffset(verifier,
VT_BASE) &&
3129 verifier.VerifyTable(base()) &&
3131 verifier.VerifyTable(descriptor()) &&
3133 verifier.VerifyTable(weights()) &&
3134 VerifyOffset(verifier, VT_BIASES) &&
3135 verifier.VerifyTable(biases()) &&
3136 verifier.EndTable();
3142 flatbuffers::FlatBufferBuilder &
fbb_;
3144 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3147 void add_descriptor(flatbuffers::Offset<armnnSerializer::Convolution2dDescriptor> descriptor) {
3150 void add_weights(flatbuffers::Offset<armnnSerializer::ConstTensor> weights) {
3153 void add_biases(flatbuffers::Offset<armnnSerializer::ConstTensor> biases) {
3154 fbb_.AddOffset(Convolution2dLayer::VT_BIASES, biases);
3158 start_ = fbb_.StartTable();
3161 flatbuffers::Offset<Convolution2dLayer>
Finish() {
3162 const auto end = fbb_.EndTable(start_);
3163 auto o = flatbuffers::Offset<Convolution2dLayer>(end);
3169 flatbuffers::FlatBufferBuilder &_fbb,
3170 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3171 flatbuffers::Offset<armnnSerializer::Convolution2dDescriptor> descriptor = 0,
3172 flatbuffers::Offset<armnnSerializer::ConstTensor> weights = 0,
3173 flatbuffers::Offset<armnnSerializer::ConstTensor> biases = 0) {
3179 return builder_.
Finish();
3182 struct Convolution2dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3184 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3203 return GetField<uint32_t>(
VT_PADTOP, 0);
3226 bool Verify(flatbuffers::Verifier &verifier)
const {
3227 return VerifyTableStart(verifier) &&
3228 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
3230 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
3232 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
3233 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
3238 verifier.EndTable();
3244 flatbuffers::FlatBufferBuilder &
fbb_;
3278 start_ = fbb_.StartTable();
3281 flatbuffers::Offset<Convolution2dDescriptor>
Finish() {
3282 const auto end = fbb_.EndTable(start_);
3283 auto o = flatbuffers::Offset<Convolution2dDescriptor>(end);
3289 flatbuffers::FlatBufferBuilder &_fbb,
3290 uint32_t padLeft = 0,
3291 uint32_t padRight = 0,
3292 uint32_t padTop = 0,
3293 uint32_t padBottom = 0,
3294 uint32_t strideX = 0,
3295 uint32_t strideY = 0,
3296 uint32_t dilationX = 1,
3297 uint32_t dilationY = 1,
3298 bool biasEnabled =
false,
3311 return builder_.
Finish();
3314 struct Convolution3dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3316 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3320 const armnnSerializer::LayerBase *
base()
const {
3321 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3323 const armnnSerializer::Convolution3dDescriptor *
descriptor()
const {
3324 return GetPointer<const armnnSerializer::Convolution3dDescriptor *>(
VT_DESCRIPTOR);
3326 bool Verify(flatbuffers::Verifier &verifier)
const {
3327 return VerifyTableStart(verifier) &&
3328 VerifyOffset(verifier,
VT_BASE) &&
3329 verifier.VerifyTable(base()) &&
3331 verifier.VerifyTable(descriptor()) &&
3332 verifier.EndTable();
3338 flatbuffers::FlatBufferBuilder &
fbb_;
3340 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3343 void add_descriptor(flatbuffers::Offset<armnnSerializer::Convolution3dDescriptor> descriptor) {
3348 start_ = fbb_.StartTable();
3351 flatbuffers::Offset<Convolution3dLayer>
Finish() {
3352 const auto end = fbb_.EndTable(start_);
3353 auto o = flatbuffers::Offset<Convolution3dLayer>(end);
3359 flatbuffers::FlatBufferBuilder &_fbb,
3360 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3361 flatbuffers::Offset<armnnSerializer::Convolution3dDescriptor> descriptor = 0) {
3365 return builder_.
Finish();
3368 struct Convolution3dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3370 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3393 return GetField<uint32_t>(
VT_PADTOP, 0);
3428 bool Verify(flatbuffers::Verifier &verifier)
const {
3429 return VerifyTableStart(verifier) &&
3430 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
3432 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
3435 VerifyField<uint32_t>(verifier,
VT_PADBACK) &&
3436 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
3437 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
3438 VerifyField<uint32_t>(verifier,
VT_STRIDEZ) &&
3444 verifier.EndTable();
3450 flatbuffers::FlatBufferBuilder &
fbb_;
3496 start_ = fbb_.StartTable();
3499 flatbuffers::Offset<Convolution3dDescriptor>
Finish() {
3500 const auto end = fbb_.EndTable(start_);
3501 auto o = flatbuffers::Offset<Convolution3dDescriptor>(end);
3507 flatbuffers::FlatBufferBuilder &_fbb,
3508 uint32_t padLeft = 0,
3509 uint32_t padRight = 0,
3510 uint32_t padTop = 0,
3511 uint32_t padBottom = 0,
3512 uint32_t padFront = 0,
3513 uint32_t padBack = 0,
3514 uint32_t strideX = 0,
3515 uint32_t strideY = 0,
3516 uint32_t strideZ = 0,
3517 uint32_t dilationX = 1,
3518 uint32_t dilationY = 1,
3519 uint32_t dilationZ = 1,
3520 bool biasEnabled =
false,
3537 return builder_.
Finish();
3540 struct DepthToSpaceLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3542 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3546 const armnnSerializer::LayerBase *
base()
const {
3547 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3550 return GetPointer<const armnnSerializer::DepthToSpaceDescriptor *>(
VT_DESCRIPTOR);
3552 bool Verify(flatbuffers::Verifier &verifier)
const {
3553 return VerifyTableStart(verifier) &&
3554 VerifyOffset(verifier,
VT_BASE) &&
3555 verifier.VerifyTable(base()) &&
3557 verifier.VerifyTable(descriptor()) &&
3558 verifier.EndTable();
3564 flatbuffers::FlatBufferBuilder &
fbb_;
3566 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3569 void add_descriptor(flatbuffers::Offset<armnnSerializer::DepthToSpaceDescriptor> descriptor) {
3574 start_ = fbb_.StartTable();
3577 flatbuffers::Offset<DepthToSpaceLayer>
Finish() {
3578 const auto end = fbb_.EndTable(start_);
3579 auto o = flatbuffers::Offset<DepthToSpaceLayer>(end);
3585 flatbuffers::FlatBufferBuilder &_fbb,
3586 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3587 flatbuffers::Offset<armnnSerializer::DepthToSpaceDescriptor> descriptor = 0) {
3591 return builder_.
Finish();
3596 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3606 bool Verify(flatbuffers::Verifier &verifier)
const {
3607 return VerifyTableStart(verifier) &&
3610 verifier.EndTable();
3616 flatbuffers::FlatBufferBuilder &
fbb_;
3626 start_ = fbb_.StartTable();
3629 flatbuffers::Offset<DepthToSpaceDescriptor>
Finish() {
3630 const auto end = fbb_.EndTable(start_);
3631 auto o = flatbuffers::Offset<DepthToSpaceDescriptor>(end);
3637 flatbuffers::FlatBufferBuilder &_fbb,
3638 uint32_t blockSize = 0,
3643 return builder_.
Finish();
3646 struct DivisionLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3648 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3651 const armnnSerializer::LayerBase *
base()
const {
3652 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3654 bool Verify(flatbuffers::Verifier &verifier)
const {
3655 return VerifyTableStart(verifier) &&
3656 VerifyOffset(verifier,
VT_BASE) &&
3657 verifier.VerifyTable(base()) &&
3658 verifier.EndTable();
3664 flatbuffers::FlatBufferBuilder &
fbb_;
3666 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3671 start_ = fbb_.StartTable();
3674 flatbuffers::Offset<DivisionLayer>
Finish() {
3675 const auto end = fbb_.EndTable(start_);
3676 auto o = flatbuffers::Offset<DivisionLayer>(end);
3682 flatbuffers::FlatBufferBuilder &_fbb,
3683 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
3686 return builder_.
Finish();
3689 struct ElementwiseUnaryDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3691 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3697 bool Verify(flatbuffers::Verifier &verifier)
const {
3698 return VerifyTableStart(verifier) &&
3699 VerifyField<int8_t>(verifier, VT_OPERATION) &&
3700 verifier.EndTable();
3705 typedef ElementwiseUnaryDescriptor
Table;
3706 flatbuffers::FlatBufferBuilder &
fbb_;
3709 fbb_.AddElement<int8_t>(ElementwiseUnaryDescriptor::VT_OPERATION,
static_cast<int8_t
>(operation), 0);
3713 start_ = fbb_.StartTable();
3716 flatbuffers::Offset<ElementwiseUnaryDescriptor>
Finish() {
3717 const auto end = fbb_.EndTable(start_);
3718 auto o = flatbuffers::Offset<ElementwiseUnaryDescriptor>(end);
3724 flatbuffers::FlatBufferBuilder &_fbb,
3728 return builder_.
Finish();
3731 struct ElementwiseUnaryLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3733 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3737 const armnnSerializer::LayerBase *
base()
const {
3738 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3740 const armnnSerializer::ElementwiseUnaryDescriptor *
descriptor()
const {
3741 return GetPointer<const armnnSerializer::ElementwiseUnaryDescriptor *>(
VT_DESCRIPTOR);
3743 bool Verify(flatbuffers::Verifier &verifier)
const {
3744 return VerifyTableStart(verifier) &&
3745 VerifyOffset(verifier,
VT_BASE) &&
3746 verifier.VerifyTable(base()) &&
3748 verifier.VerifyTable(descriptor()) &&
3749 verifier.EndTable();
3755 flatbuffers::FlatBufferBuilder &
fbb_;
3757 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3760 void add_descriptor(flatbuffers::Offset<armnnSerializer::ElementwiseUnaryDescriptor> descriptor) {
3765 start_ = fbb_.StartTable();
3768 flatbuffers::Offset<ElementwiseUnaryLayer>
Finish() {
3769 const auto end = fbb_.EndTable(start_);
3770 auto o = flatbuffers::Offset<ElementwiseUnaryLayer>(end);
3776 flatbuffers::FlatBufferBuilder &_fbb,
3777 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3778 flatbuffers::Offset<armnnSerializer::ElementwiseUnaryDescriptor> descriptor = 0) {
3782 return builder_.
Finish();
3786 struct EqualLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3788 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3791 const armnnSerializer::LayerBase *
base()
const {
3792 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3794 bool Verify(flatbuffers::Verifier &verifier)
const {
3795 return VerifyTableStart(verifier) &&
3796 VerifyOffset(verifier,
VT_BASE) &&
3797 verifier.VerifyTable(base()) &&
3798 verifier.EndTable();
3804 flatbuffers::FlatBufferBuilder &
fbb_;
3806 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3811 start_ = fbb_.StartTable();
3815 const auto end = fbb_.EndTable(start_);
3816 auto o = flatbuffers::Offset<EqualLayer>(end);
3822 flatbuffers::FlatBufferBuilder &_fbb,
3823 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
3826 return builder_.
Finish();
3829 struct FillLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3831 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3835 const armnnSerializer::LayerBase *
base()
const {
3836 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3839 return GetPointer<const armnnSerializer::FillDescriptor *>(
VT_DESCRIPTOR);
3841 bool Verify(flatbuffers::Verifier &verifier)
const {
3842 return VerifyTableStart(verifier) &&
3843 VerifyOffset(verifier,
VT_BASE) &&
3844 verifier.VerifyTable(base()) &&
3846 verifier.VerifyTable(descriptor()) &&
3847 verifier.EndTable();
3853 flatbuffers::FlatBufferBuilder &
fbb_;
3855 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3858 void add_descriptor(flatbuffers::Offset<armnnSerializer::FillDescriptor> descriptor) {
3863 start_ = fbb_.StartTable();
3867 const auto end = fbb_.EndTable(start_);
3868 auto o = flatbuffers::Offset<FillLayer>(end);
3874 flatbuffers::FlatBufferBuilder &_fbb,
3875 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
3876 flatbuffers::Offset<armnnSerializer::FillDescriptor> descriptor = 0) {
3880 return builder_.
Finish();
3883 struct FillDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3885 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3889 return GetField<float>(VT_VALUE, 0.0f);
3891 bool Verify(flatbuffers::Verifier &verifier)
const {
3892 return VerifyTableStart(verifier) &&
3893 VerifyField<float>(verifier, VT_VALUE) &&
3894 verifier.EndTable();
3900 flatbuffers::FlatBufferBuilder &
fbb_;
3903 fbb_.AddElement<
float>(FillDescriptor::VT_VALUE, value, 0.0f);
3907 start_ = fbb_.StartTable();
3910 flatbuffers::Offset<FillDescriptor>
Finish() {
3911 const auto end = fbb_.EndTable(start_);
3912 auto o = flatbuffers::Offset<FillDescriptor>(end);
3918 flatbuffers::FlatBufferBuilder &_fbb,
3919 float value = 0.0f) {
3922 return builder_.
Finish();
3925 struct FloorLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3927 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3930 const armnnSerializer::LayerBase *
base()
const {
3931 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3933 bool Verify(flatbuffers::Verifier &verifier)
const {
3934 return VerifyTableStart(verifier) &&
3935 VerifyOffset(verifier,
VT_BASE) &&
3936 verifier.VerifyTable(base()) &&
3937 verifier.EndTable();
3943 flatbuffers::FlatBufferBuilder &
fbb_;
3945 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
3950 start_ = fbb_.StartTable();
3954 const auto end = fbb_.EndTable(start_);
3955 auto o = flatbuffers::Offset<FloorLayer>(end);
3961 flatbuffers::FlatBufferBuilder &_fbb,
3962 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
3965 return builder_.
Finish();
3968 struct FullyConnectedLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
3970 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3976 const armnnSerializer::LayerBase *
base()
const {
3977 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
3979 const armnnSerializer::FullyConnectedDescriptor *
descriptor()
const {
3980 return GetPointer<const armnnSerializer::FullyConnectedDescriptor *>(
VT_DESCRIPTOR);
3982 const armnnSerializer::ConstTensor *
weights()
const {
3983 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_WEIGHTS);
3985 const armnnSerializer::ConstTensor *
biases()
const {
3986 return GetPointer<const armnnSerializer::ConstTensor *>(VT_BIASES);
3988 bool Verify(flatbuffers::Verifier &verifier)
const {
3989 return VerifyTableStart(verifier) &&
3990 VerifyOffset(verifier,
VT_BASE) &&
3991 verifier.VerifyTable(base()) &&
3993 verifier.VerifyTable(descriptor()) &&
3995 verifier.VerifyTable(weights()) &&
3996 VerifyOffset(verifier, VT_BIASES) &&
3997 verifier.VerifyTable(biases()) &&
3998 verifier.EndTable();
4004 flatbuffers::FlatBufferBuilder &
fbb_;
4006 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4009 void add_descriptor(flatbuffers::Offset<armnnSerializer::FullyConnectedDescriptor> descriptor) {
4012 void add_weights(flatbuffers::Offset<armnnSerializer::ConstTensor> weights) {
4015 void add_biases(flatbuffers::Offset<armnnSerializer::ConstTensor> biases) {
4016 fbb_.AddOffset(FullyConnectedLayer::VT_BIASES, biases);
4020 start_ = fbb_.StartTable();
4023 flatbuffers::Offset<FullyConnectedLayer>
Finish() {
4024 const auto end = fbb_.EndTable(start_);
4025 auto o = flatbuffers::Offset<FullyConnectedLayer>(end);
4031 flatbuffers::FlatBufferBuilder &_fbb,
4032 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4033 flatbuffers::Offset<armnnSerializer::FullyConnectedDescriptor> descriptor = 0,
4034 flatbuffers::Offset<armnnSerializer::ConstTensor> weights = 0,
4035 flatbuffers::Offset<armnnSerializer::ConstTensor> biases = 0) {
4041 return builder_.
Finish();
4044 struct FullyConnectedDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4046 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4049 VT_CONSTANTWEIGHTS = 8
4058 return GetField<uint8_t>(VT_CONSTANTWEIGHTS, 1) != 0;
4060 bool Verify(flatbuffers::Verifier &verifier)
const {
4061 return VerifyTableStart(verifier) &&
4064 VerifyField<uint8_t>(verifier, VT_CONSTANTWEIGHTS) &&
4065 verifier.EndTable();
4071 flatbuffers::FlatBufferBuilder &
fbb_;
4080 fbb_.AddElement<uint8_t>(FullyConnectedDescriptor::VT_CONSTANTWEIGHTS,
static_cast<uint8_t
>(constantWeights), 1);
4084 start_ = fbb_.StartTable();
4087 flatbuffers::Offset<FullyConnectedDescriptor>
Finish() {
4088 const auto end = fbb_.EndTable(start_);
4089 auto o = flatbuffers::Offset<FullyConnectedDescriptor>(end);
4095 flatbuffers::FlatBufferBuilder &_fbb,
4096 bool biasEnabled =
false,
4097 bool transposeWeightsMatrix =
false,
4098 bool constantWeights =
true) {
4103 return builder_.
Finish();
4106 struct GatherLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4108 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4112 const armnnSerializer::LayerBase *
base()
const {
4113 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4116 return GetPointer<const armnnSerializer::GatherDescriptor *>(
VT_DESCRIPTOR);
4118 bool Verify(flatbuffers::Verifier &verifier)
const {
4119 return VerifyTableStart(verifier) &&
4120 VerifyOffset(verifier,
VT_BASE) &&
4121 verifier.VerifyTable(base()) &&
4123 verifier.VerifyTable(descriptor()) &&
4124 verifier.EndTable();
4130 flatbuffers::FlatBufferBuilder &
fbb_;
4132 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4135 void add_descriptor(flatbuffers::Offset<armnnSerializer::GatherDescriptor> descriptor) {
4140 start_ = fbb_.StartTable();
4144 const auto end = fbb_.EndTable(start_);
4145 auto o = flatbuffers::Offset<GatherLayer>(end);
4151 flatbuffers::FlatBufferBuilder &_fbb,
4152 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4153 flatbuffers::Offset<armnnSerializer::GatherDescriptor> descriptor = 0) {
4157 return builder_.
Finish();
4160 struct GatherDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4162 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4166 return GetField<int32_t>(
VT_AXIS, 0);
4168 bool Verify(flatbuffers::Verifier &verifier)
const {
4169 return VerifyTableStart(verifier) &&
4170 VerifyField<int32_t>(verifier,
VT_AXIS) &&
4171 verifier.EndTable();
4177 flatbuffers::FlatBufferBuilder &
fbb_;
4184 start_ = fbb_.StartTable();
4187 flatbuffers::Offset<GatherDescriptor>
Finish() {
4188 const auto end = fbb_.EndTable(start_);
4189 auto o = flatbuffers::Offset<GatherDescriptor>(end);
4195 flatbuffers::FlatBufferBuilder &_fbb,
4199 return builder_.
Finish();
4202 struct GatherNdLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4204 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4207 const armnnSerializer::LayerBase *
base()
const {
4208 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4210 bool Verify(flatbuffers::Verifier &verifier)
const {
4211 return VerifyTableStart(verifier) &&
4212 VerifyOffset(verifier,
VT_BASE) &&
4213 verifier.VerifyTable(base()) &&
4214 verifier.EndTable();
4220 flatbuffers::FlatBufferBuilder &
fbb_;
4222 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4227 start_ = fbb_.StartTable();
4230 flatbuffers::Offset<GatherNdLayer>
Finish() {
4231 const auto end = fbb_.EndTable(start_);
4232 auto o = flatbuffers::Offset<GatherNdLayer>(end);
4238 flatbuffers::FlatBufferBuilder &_fbb,
4239 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4242 return builder_.
Finish();
4246 struct GreaterLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4248 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4251 const armnnSerializer::LayerBase *
base()
const {
4252 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4254 bool Verify(flatbuffers::Verifier &verifier)
const {
4255 return VerifyTableStart(verifier) &&
4256 VerifyOffset(verifier,
VT_BASE) &&
4257 verifier.VerifyTable(base()) &&
4258 verifier.EndTable();
4264 flatbuffers::FlatBufferBuilder &
fbb_;
4266 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4271 start_ = fbb_.StartTable();
4275 const auto end = fbb_.EndTable(start_);
4276 auto o = flatbuffers::Offset<GreaterLayer>(end);
4282 flatbuffers::FlatBufferBuilder &_fbb,
4283 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4286 return builder_.
Finish();
4289 struct InputLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4291 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4294 const armnnSerializer::BindableLayerBase *
base()
const {
4295 return GetPointer<const armnnSerializer::BindableLayerBase *>(
VT_BASE);
4297 bool Verify(flatbuffers::Verifier &verifier)
const {
4298 return VerifyTableStart(verifier) &&
4299 VerifyOffset(verifier,
VT_BASE) &&
4300 verifier.VerifyTable(base()) &&
4301 verifier.EndTable();
4307 flatbuffers::FlatBufferBuilder &
fbb_;
4309 void add_base(flatbuffers::Offset<armnnSerializer::BindableLayerBase> base) {
4314 start_ = fbb_.StartTable();
4318 const auto end = fbb_.EndTable(start_);
4319 auto o = flatbuffers::Offset<InputLayer>(end);
4325 flatbuffers::FlatBufferBuilder &_fbb,
4326 flatbuffers::Offset<armnnSerializer::BindableLayerBase> base = 0) {
4329 return builder_.
Finish();
4332 struct InstanceNormalizationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4334 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4338 const armnnSerializer::LayerBase *
base()
const {
4339 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4341 const armnnSerializer::InstanceNormalizationDescriptor *
descriptor()
const {
4342 return GetPointer<const armnnSerializer::InstanceNormalizationDescriptor *>(
VT_DESCRIPTOR);
4344 bool Verify(flatbuffers::Verifier &verifier)
const {
4345 return VerifyTableStart(verifier) &&
4346 VerifyOffset(verifier,
VT_BASE) &&
4347 verifier.VerifyTable(base()) &&
4349 verifier.VerifyTable(descriptor()) &&
4350 verifier.EndTable();
4355 typedef InstanceNormalizationLayer
Table;
4356 flatbuffers::FlatBufferBuilder &
fbb_;
4358 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4361 void add_descriptor(flatbuffers::Offset<armnnSerializer::InstanceNormalizationDescriptor> descriptor) {
4366 start_ = fbb_.StartTable();
4369 flatbuffers::Offset<InstanceNormalizationLayer>
Finish() {
4370 const auto end = fbb_.EndTable(start_);
4371 auto o = flatbuffers::Offset<InstanceNormalizationLayer>(end);
4377 flatbuffers::FlatBufferBuilder &_fbb,
4378 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4379 flatbuffers::Offset<armnnSerializer::InstanceNormalizationDescriptor> descriptor = 0) {
4383 return builder_.
Finish();
4386 struct InstanceNormalizationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4388 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4395 return GetField<float>(
VT_GAMMA, 0.0f);
4398 return GetField<float>(
VT_BETA, 0.0f);
4401 return GetField<float>(
VT_EPS, 0.0f);
4406 bool Verify(flatbuffers::Verifier &verifier)
const {
4407 return VerifyTableStart(verifier) &&
4408 VerifyField<float>(verifier,
VT_GAMMA) &&
4409 VerifyField<float>(verifier,
VT_BETA) &&
4410 VerifyField<float>(verifier,
VT_EPS) &&
4412 verifier.EndTable();
4417 typedef InstanceNormalizationDescriptor
Table;
4418 flatbuffers::FlatBufferBuilder &
fbb_;
4434 start_ = fbb_.StartTable();
4437 flatbuffers::Offset<InstanceNormalizationDescriptor>
Finish() {
4438 const auto end = fbb_.EndTable(start_);
4439 auto o = flatbuffers::Offset<InstanceNormalizationDescriptor>(end);
4445 flatbuffers::FlatBufferBuilder &_fbb,
4455 return builder_.
Finish();
4458 struct LogSoftmaxLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4460 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4464 const armnnSerializer::LayerBase *
base()
const {
4465 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4468 return GetPointer<const armnnSerializer::LogSoftmaxDescriptor *>(
VT_DESCRIPTOR);
4470 bool Verify(flatbuffers::Verifier &verifier)
const {
4471 return VerifyTableStart(verifier) &&
4472 VerifyOffset(verifier,
VT_BASE) &&
4473 verifier.VerifyTable(base()) &&
4475 verifier.VerifyTable(descriptor()) &&
4476 verifier.EndTable();
4482 flatbuffers::FlatBufferBuilder &
fbb_;
4484 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4487 void add_descriptor(flatbuffers::Offset<armnnSerializer::LogSoftmaxDescriptor> descriptor) {
4492 start_ = fbb_.StartTable();
4495 flatbuffers::Offset<LogSoftmaxLayer>
Finish() {
4496 const auto end = fbb_.EndTable(start_);
4497 auto o = flatbuffers::Offset<LogSoftmaxLayer>(end);
4503 flatbuffers::FlatBufferBuilder &_fbb,
4504 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4505 flatbuffers::Offset<armnnSerializer::LogSoftmaxDescriptor> descriptor = 0) {
4509 return builder_.
Finish();
4514 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4519 return GetField<float>(
VT_BETA, 1.0f);
4522 return GetField<int32_t>(
VT_AXIS, -1);
4524 bool Verify(flatbuffers::Verifier &verifier)
const {
4525 return VerifyTableStart(verifier) &&
4526 VerifyField<float>(verifier,
VT_BETA) &&
4527 VerifyField<int32_t>(verifier,
VT_AXIS) &&
4528 verifier.EndTable();
4534 flatbuffers::FlatBufferBuilder &
fbb_;
4544 start_ = fbb_.StartTable();
4547 flatbuffers::Offset<LogSoftmaxDescriptor>
Finish() {
4548 const auto end = fbb_.EndTable(start_);
4549 auto o = flatbuffers::Offset<LogSoftmaxDescriptor>(end);
4555 flatbuffers::FlatBufferBuilder &_fbb,
4557 int32_t axis = -1) {
4561 return builder_.
Finish();
4564 struct L2NormalizationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4566 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4570 const armnnSerializer::LayerBase *
base()
const {
4571 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4573 const armnnSerializer::L2NormalizationDescriptor *
descriptor()
const {
4574 return GetPointer<const armnnSerializer::L2NormalizationDescriptor *>(
VT_DESCRIPTOR);
4576 bool Verify(flatbuffers::Verifier &verifier)
const {
4577 return VerifyTableStart(verifier) &&
4578 VerifyOffset(verifier,
VT_BASE) &&
4579 verifier.VerifyTable(base()) &&
4581 verifier.VerifyTable(descriptor()) &&
4582 verifier.EndTable();
4588 flatbuffers::FlatBufferBuilder &
fbb_;
4590 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4593 void add_descriptor(flatbuffers::Offset<armnnSerializer::L2NormalizationDescriptor> descriptor) {
4598 start_ = fbb_.StartTable();
4601 flatbuffers::Offset<L2NormalizationLayer>
Finish() {
4602 const auto end = fbb_.EndTable(start_);
4603 auto o = flatbuffers::Offset<L2NormalizationLayer>(end);
4609 flatbuffers::FlatBufferBuilder &_fbb,
4610 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4611 flatbuffers::Offset<armnnSerializer::L2NormalizationDescriptor> descriptor = 0) {
4615 return builder_.
Finish();
4618 struct L2NormalizationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4620 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4628 return GetField<float>(
VT_EPS, 1e-12f);
4630 bool Verify(flatbuffers::Verifier &verifier)
const {
4631 return VerifyTableStart(verifier) &&
4633 VerifyField<float>(verifier,
VT_EPS) &&
4634 verifier.EndTable();
4639 typedef L2NormalizationDescriptor
Table;
4640 flatbuffers::FlatBufferBuilder &
fbb_;
4650 start_ = fbb_.StartTable();
4653 flatbuffers::Offset<L2NormalizationDescriptor>
Finish() {
4654 const auto end = fbb_.EndTable(start_);
4655 auto o = flatbuffers::Offset<L2NormalizationDescriptor>(end);
4661 flatbuffers::FlatBufferBuilder &_fbb,
4663 float eps = 1e-12f) {
4667 return builder_.
Finish();
4670 struct LogicalBinaryDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4672 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4678 bool Verify(flatbuffers::Verifier &verifier)
const {
4679 return VerifyTableStart(verifier) &&
4680 VerifyField<int8_t>(verifier, VT_OPERATION) &&
4681 verifier.EndTable();
4687 flatbuffers::FlatBufferBuilder &
fbb_;
4690 fbb_.AddElement<int8_t>(LogicalBinaryDescriptor::VT_OPERATION,
static_cast<int8_t
>(operation), 0);
4694 start_ = fbb_.StartTable();
4697 flatbuffers::Offset<LogicalBinaryDescriptor>
Finish() {
4698 const auto end = fbb_.EndTable(start_);
4699 auto o = flatbuffers::Offset<LogicalBinaryDescriptor>(end);
4705 flatbuffers::FlatBufferBuilder &_fbb,
4709 return builder_.
Finish();
4712 struct LogicalBinaryLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4714 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4718 const armnnSerializer::LayerBase *
base()
const {
4719 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4721 const armnnSerializer::LogicalBinaryDescriptor *
descriptor()
const {
4722 return GetPointer<const armnnSerializer::LogicalBinaryDescriptor *>(
VT_DESCRIPTOR);
4724 bool Verify(flatbuffers::Verifier &verifier)
const {
4725 return VerifyTableStart(verifier) &&
4726 VerifyOffset(verifier,
VT_BASE) &&
4727 verifier.VerifyTable(base()) &&
4729 verifier.VerifyTable(descriptor()) &&
4730 verifier.EndTable();
4736 flatbuffers::FlatBufferBuilder &
fbb_;
4738 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4741 void add_descriptor(flatbuffers::Offset<armnnSerializer::LogicalBinaryDescriptor> descriptor) {
4746 start_ = fbb_.StartTable();
4749 flatbuffers::Offset<LogicalBinaryLayer>
Finish() {
4750 const auto end = fbb_.EndTable(start_);
4751 auto o = flatbuffers::Offset<LogicalBinaryLayer>(end);
4757 flatbuffers::FlatBufferBuilder &_fbb,
4758 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4759 flatbuffers::Offset<armnnSerializer::LogicalBinaryDescriptor> descriptor = 0) {
4763 return builder_.
Finish();
4766 struct MinimumLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4768 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4771 const armnnSerializer::LayerBase *
base()
const {
4772 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4774 bool Verify(flatbuffers::Verifier &verifier)
const {
4775 return VerifyTableStart(verifier) &&
4776 VerifyOffset(verifier,
VT_BASE) &&
4777 verifier.VerifyTable(base()) &&
4778 verifier.EndTable();
4784 flatbuffers::FlatBufferBuilder &
fbb_;
4786 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4791 start_ = fbb_.StartTable();
4795 const auto end = fbb_.EndTable(start_);
4796 auto o = flatbuffers::Offset<MinimumLayer>(end);
4802 flatbuffers::FlatBufferBuilder &_fbb,
4803 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4806 return builder_.
Finish();
4809 struct MaximumLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4811 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4814 const armnnSerializer::LayerBase *
base()
const {
4815 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4817 bool Verify(flatbuffers::Verifier &verifier)
const {
4818 return VerifyTableStart(verifier) &&
4819 VerifyOffset(verifier,
VT_BASE) &&
4820 verifier.VerifyTable(base()) &&
4821 verifier.EndTable();
4827 flatbuffers::FlatBufferBuilder &
fbb_;
4829 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4834 start_ = fbb_.StartTable();
4838 const auto end = fbb_.EndTable(start_);
4839 auto o = flatbuffers::Offset<MaximumLayer>(end);
4845 flatbuffers::FlatBufferBuilder &_fbb,
4846 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4849 return builder_.
Finish();
4852 struct MultiplicationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4854 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4857 const armnnSerializer::LayerBase *
base()
const {
4858 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4860 bool Verify(flatbuffers::Verifier &verifier)
const {
4861 return VerifyTableStart(verifier) &&
4862 VerifyOffset(verifier,
VT_BASE) &&
4863 verifier.VerifyTable(base()) &&
4864 verifier.EndTable();
4870 flatbuffers::FlatBufferBuilder &
fbb_;
4872 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4877 start_ = fbb_.StartTable();
4880 flatbuffers::Offset<MultiplicationLayer>
Finish() {
4881 const auto end = fbb_.EndTable(start_);
4882 auto o = flatbuffers::Offset<MultiplicationLayer>(end);
4888 flatbuffers::FlatBufferBuilder &_fbb,
4889 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
4892 return builder_.
Finish();
4895 struct Pooling2dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4897 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4901 const armnnSerializer::LayerBase *
base()
const {
4902 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4905 return GetPointer<const armnnSerializer::Pooling2dDescriptor *>(
VT_DESCRIPTOR);
4907 bool Verify(flatbuffers::Verifier &verifier)
const {
4908 return VerifyTableStart(verifier) &&
4909 VerifyOffset(verifier,
VT_BASE) &&
4910 verifier.VerifyTable(base()) &&
4912 verifier.VerifyTable(descriptor()) &&
4913 verifier.EndTable();
4919 flatbuffers::FlatBufferBuilder &
fbb_;
4921 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4924 void add_descriptor(flatbuffers::Offset<armnnSerializer::Pooling2dDescriptor> descriptor) {
4929 start_ = fbb_.StartTable();
4932 flatbuffers::Offset<Pooling2dLayer>
Finish() {
4933 const auto end = fbb_.EndTable(start_);
4934 auto o = flatbuffers::Offset<Pooling2dLayer>(end);
4940 flatbuffers::FlatBufferBuilder &_fbb,
4941 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4942 flatbuffers::Offset<armnnSerializer::Pooling2dDescriptor> descriptor = 0) {
4946 return builder_.
Finish();
4949 struct Pooling3dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
4951 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4955 const armnnSerializer::LayerBase *
base()
const {
4956 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
4959 return GetPointer<const armnnSerializer::Pooling3dDescriptor *>(
VT_DESCRIPTOR);
4961 bool Verify(flatbuffers::Verifier &verifier)
const {
4962 return VerifyTableStart(verifier) &&
4963 VerifyOffset(verifier,
VT_BASE) &&
4964 verifier.VerifyTable(base()) &&
4966 verifier.VerifyTable(descriptor()) &&
4967 verifier.EndTable();
4973 flatbuffers::FlatBufferBuilder &
fbb_;
4975 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
4978 void add_descriptor(flatbuffers::Offset<armnnSerializer::Pooling3dDescriptor> descriptor) {
4983 start_ = fbb_.StartTable();
4986 flatbuffers::Offset<Pooling3dLayer>
Finish() {
4987 const auto end = fbb_.EndTable(start_);
4988 auto o = flatbuffers::Offset<Pooling3dLayer>(end);
4994 flatbuffers::FlatBufferBuilder &_fbb,
4995 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
4996 flatbuffers::Offset<armnnSerializer::Pooling3dDescriptor> descriptor = 0) {
5000 return builder_.
Finish();
5005 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5029 return GetField<uint32_t>(
VT_PADTOP, 0);
5055 bool Verify(flatbuffers::Verifier &verifier)
const {
5056 return VerifyTableStart(verifier) &&
5058 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
5060 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
5064 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
5065 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
5069 verifier.EndTable();
5075 flatbuffers::FlatBufferBuilder &
fbb_;
5115 start_ = fbb_.StartTable();
5118 flatbuffers::Offset<Pooling2dDescriptor>
Finish() {
5119 const auto end = fbb_.EndTable(start_);
5120 auto o = flatbuffers::Offset<Pooling2dDescriptor>(end);
5126 flatbuffers::FlatBufferBuilder &_fbb,
5128 uint32_t padLeft = 0,
5129 uint32_t padRight = 0,
5130 uint32_t padTop = 0,
5131 uint32_t padBottom = 0,
5132 uint32_t poolWidth = 0,
5133 uint32_t poolHeight = 0,
5134 uint32_t strideX = 0,
5135 uint32_t strideY = 0,
5152 return builder_.
Finish();
5157 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5185 return GetField<uint32_t>(
VT_PADTOP, 0);
5223 bool Verify(flatbuffers::Verifier &verifier)
const {
5224 return VerifyTableStart(verifier) &&
5226 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
5228 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
5231 VerifyField<uint32_t>(verifier,
VT_PADBACK) &&
5235 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
5236 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
5237 VerifyField<uint32_t>(verifier,
VT_STRIDEZ) &&
5241 verifier.EndTable();
5247 flatbuffers::FlatBufferBuilder &
fbb_;
5299 start_ = fbb_.StartTable();
5302 flatbuffers::Offset<Pooling3dDescriptor>
Finish() {
5303 const auto end = fbb_.EndTable(start_);
5304 auto o = flatbuffers::Offset<Pooling3dDescriptor>(end);
5310 flatbuffers::FlatBufferBuilder &_fbb,
5312 uint32_t padLeft = 0,
5313 uint32_t padRight = 0,
5314 uint32_t padTop = 0,
5315 uint32_t padBottom = 0,
5316 uint32_t padFront = 0,
5317 uint32_t padBack = 0,
5318 uint32_t poolWidth = 0,
5319 uint32_t poolHeight = 0,
5320 uint32_t poolDepth = 0,
5321 uint32_t strideX = 0,
5322 uint32_t strideY = 0,
5323 uint32_t strideZ = 0,
5344 return builder_.
Finish();
5347 struct QuantizeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5349 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5352 const armnnSerializer::LayerBase *
base()
const {
5353 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5355 bool Verify(flatbuffers::Verifier &verifier)
const {
5356 return VerifyTableStart(verifier) &&
5357 VerifyOffset(verifier,
VT_BASE) &&
5358 verifier.VerifyTable(base()) &&
5359 verifier.EndTable();
5365 flatbuffers::FlatBufferBuilder &
fbb_;
5367 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5372 start_ = fbb_.StartTable();
5375 flatbuffers::Offset<QuantizeLayer>
Finish() {
5376 const auto end = fbb_.EndTable(start_);
5377 auto o = flatbuffers::Offset<QuantizeLayer>(end);
5383 flatbuffers::FlatBufferBuilder &_fbb,
5384 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
5387 return builder_.
Finish();
5390 struct SoftmaxLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5392 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5396 const armnnSerializer::LayerBase *
base()
const {
5397 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5400 return GetPointer<const armnnSerializer::SoftmaxDescriptor *>(
VT_DESCRIPTOR);
5402 bool Verify(flatbuffers::Verifier &verifier)
const {
5403 return VerifyTableStart(verifier) &&
5404 VerifyOffset(verifier,
VT_BASE) &&
5405 verifier.VerifyTable(base()) &&
5407 verifier.VerifyTable(descriptor()) &&
5408 verifier.EndTable();
5414 flatbuffers::FlatBufferBuilder &
fbb_;
5416 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5419 void add_descriptor(flatbuffers::Offset<armnnSerializer::SoftmaxDescriptor> descriptor) {
5424 start_ = fbb_.StartTable();
5428 const auto end = fbb_.EndTable(start_);
5429 auto o = flatbuffers::Offset<SoftmaxLayer>(end);
5435 flatbuffers::FlatBufferBuilder &_fbb,
5436 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5437 flatbuffers::Offset<armnnSerializer::SoftmaxDescriptor> descriptor = 0) {
5441 return builder_.
Finish();
5444 struct SoftmaxDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5446 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5451 return GetField<float>(
VT_BETA, 0.0f);
5454 return GetField<int32_t>(
VT_AXIS, -1);
5456 bool Verify(flatbuffers::Verifier &verifier)
const {
5457 return VerifyTableStart(verifier) &&
5458 VerifyField<float>(verifier,
VT_BETA) &&
5459 VerifyField<int32_t>(verifier,
VT_AXIS) &&
5460 verifier.EndTable();
5466 flatbuffers::FlatBufferBuilder &
fbb_;
5476 start_ = fbb_.StartTable();
5479 flatbuffers::Offset<SoftmaxDescriptor>
Finish() {
5480 const auto end = fbb_.EndTable(start_);
5481 auto o = flatbuffers::Offset<SoftmaxDescriptor>(end);
5487 flatbuffers::FlatBufferBuilder &_fbb,
5489 int32_t axis = -1) {
5493 return builder_.
Finish();
5496 struct DepthwiseConvolution2dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5498 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5504 const armnnSerializer::LayerBase *
base()
const {
5505 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5507 const armnnSerializer::DepthwiseConvolution2dDescriptor *
descriptor()
const {
5508 return GetPointer<const armnnSerializer::DepthwiseConvolution2dDescriptor *>(
VT_DESCRIPTOR);
5510 const armnnSerializer::ConstTensor *
weights()
const {
5511 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_WEIGHTS);
5513 const armnnSerializer::ConstTensor *
biases()
const {
5514 return GetPointer<const armnnSerializer::ConstTensor *>(VT_BIASES);
5516 bool Verify(flatbuffers::Verifier &verifier)
const {
5517 return VerifyTableStart(verifier) &&
5518 VerifyOffset(verifier,
VT_BASE) &&
5519 verifier.VerifyTable(base()) &&
5521 verifier.VerifyTable(descriptor()) &&
5523 verifier.VerifyTable(weights()) &&
5524 VerifyOffset(verifier, VT_BIASES) &&
5525 verifier.VerifyTable(biases()) &&
5526 verifier.EndTable();
5531 typedef DepthwiseConvolution2dLayer
Table;
5532 flatbuffers::FlatBufferBuilder &
fbb_;
5534 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5537 void add_descriptor(flatbuffers::Offset<armnnSerializer::DepthwiseConvolution2dDescriptor> descriptor) {
5540 void add_weights(flatbuffers::Offset<armnnSerializer::ConstTensor> weights) {
5543 void add_biases(flatbuffers::Offset<armnnSerializer::ConstTensor> biases) {
5544 fbb_.AddOffset(DepthwiseConvolution2dLayer::VT_BIASES, biases);
5548 start_ = fbb_.StartTable();
5551 flatbuffers::Offset<DepthwiseConvolution2dLayer>
Finish() {
5552 const auto end = fbb_.EndTable(start_);
5553 auto o = flatbuffers::Offset<DepthwiseConvolution2dLayer>(end);
5559 flatbuffers::FlatBufferBuilder &_fbb,
5560 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5561 flatbuffers::Offset<armnnSerializer::DepthwiseConvolution2dDescriptor> descriptor = 0,
5562 flatbuffers::Offset<armnnSerializer::ConstTensor> weights = 0,
5563 flatbuffers::Offset<armnnSerializer::ConstTensor> biases = 0) {
5569 return builder_.
Finish();
5572 struct DepthwiseConvolution2dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5574 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5593 return GetField<uint32_t>(
VT_PADTOP, 0);
5616 bool Verify(flatbuffers::Verifier &verifier)
const {
5617 return VerifyTableStart(verifier) &&
5618 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
5620 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
5622 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
5623 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
5628 verifier.EndTable();
5633 typedef DepthwiseConvolution2dDescriptor
Table;
5634 flatbuffers::FlatBufferBuilder &
fbb_;
5668 start_ = fbb_.StartTable();
5671 flatbuffers::Offset<DepthwiseConvolution2dDescriptor>
Finish() {
5672 const auto end = fbb_.EndTable(start_);
5673 auto o = flatbuffers::Offset<DepthwiseConvolution2dDescriptor>(end);
5679 flatbuffers::FlatBufferBuilder &_fbb,
5680 uint32_t padLeft = 0,
5681 uint32_t padRight = 0,
5682 uint32_t padTop = 0,
5683 uint32_t padBottom = 0,
5684 uint32_t strideX = 0,
5685 uint32_t strideY = 0,
5686 uint32_t dilationX = 1,
5687 uint32_t dilationY = 1,
5688 bool biasEnabled =
false,
5701 return builder_.
Finish();
5704 struct OutputLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5706 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5709 const armnnSerializer::BindableLayerBase *
base()
const {
5710 return GetPointer<const armnnSerializer::BindableLayerBase *>(
VT_BASE);
5712 bool Verify(flatbuffers::Verifier &verifier)
const {
5713 return VerifyTableStart(verifier) &&
5714 VerifyOffset(verifier,
VT_BASE) &&
5715 verifier.VerifyTable(base()) &&
5716 verifier.EndTable();
5722 flatbuffers::FlatBufferBuilder &
fbb_;
5724 void add_base(flatbuffers::Offset<armnnSerializer::BindableLayerBase> base) {
5729 start_ = fbb_.StartTable();
5733 const auto end = fbb_.EndTable(start_);
5734 auto o = flatbuffers::Offset<OutputLayer>(end);
5740 flatbuffers::FlatBufferBuilder &_fbb,
5741 flatbuffers::Offset<armnnSerializer::BindableLayerBase> base = 0) {
5744 return builder_.
Finish();
5747 struct ReshapeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5749 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5753 const armnnSerializer::LayerBase *
base()
const {
5754 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5757 return GetPointer<const armnnSerializer::ReshapeDescriptor *>(
VT_DESCRIPTOR);
5759 bool Verify(flatbuffers::Verifier &verifier)
const {
5760 return VerifyTableStart(verifier) &&
5761 VerifyOffset(verifier,
VT_BASE) &&
5762 verifier.VerifyTable(base()) &&
5764 verifier.VerifyTable(descriptor()) &&
5765 verifier.EndTable();
5771 flatbuffers::FlatBufferBuilder &
fbb_;
5773 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5776 void add_descriptor(flatbuffers::Offset<armnnSerializer::ReshapeDescriptor> descriptor) {
5781 start_ = fbb_.StartTable();
5785 const auto end = fbb_.EndTable(start_);
5786 auto o = flatbuffers::Offset<ReshapeLayer>(end);
5792 flatbuffers::FlatBufferBuilder &_fbb,
5793 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5794 flatbuffers::Offset<armnnSerializer::ReshapeDescriptor> descriptor = 0) {
5798 return builder_.
Finish();
5801 struct ReshapeDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5803 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5807 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_TARGETSHAPE);
5809 bool Verify(flatbuffers::Verifier &verifier)
const {
5810 return VerifyTableStart(verifier) &&
5811 VerifyOffset(verifier, VT_TARGETSHAPE) &&
5812 verifier.VerifyVector(targetShape()) &&
5813 verifier.EndTable();
5819 flatbuffers::FlatBufferBuilder &
fbb_;
5822 fbb_.AddOffset(ReshapeDescriptor::VT_TARGETSHAPE, targetShape);
5826 start_ = fbb_.StartTable();
5829 flatbuffers::Offset<ReshapeDescriptor>
Finish() {
5830 const auto end = fbb_.EndTable(start_);
5831 auto o = flatbuffers::Offset<ReshapeDescriptor>(end);
5837 flatbuffers::FlatBufferBuilder &_fbb,
5841 return builder_.
Finish();
5845 flatbuffers::FlatBufferBuilder &_fbb,
5846 const std::vector<uint32_t> *targetShape =
nullptr) {
5847 auto targetShape__ = targetShape ? _fbb.CreateVector<uint32_t>(*targetShape) : 0;
5853 struct PermuteLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5855 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5859 const armnnSerializer::LayerBase *
base()
const {
5860 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5863 return GetPointer<const armnnSerializer::PermuteDescriptor *>(
VT_DESCRIPTOR);
5865 bool Verify(flatbuffers::Verifier &verifier)
const {
5866 return VerifyTableStart(verifier) &&
5867 VerifyOffset(verifier,
VT_BASE) &&
5868 verifier.VerifyTable(base()) &&
5870 verifier.VerifyTable(descriptor()) &&
5871 verifier.EndTable();
5877 flatbuffers::FlatBufferBuilder &
fbb_;
5879 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5882 void add_descriptor(flatbuffers::Offset<armnnSerializer::PermuteDescriptor> descriptor) {
5887 start_ = fbb_.StartTable();
5891 const auto end = fbb_.EndTable(start_);
5892 auto o = flatbuffers::Offset<PermuteLayer>(end);
5898 flatbuffers::FlatBufferBuilder &_fbb,
5899 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
5900 flatbuffers::Offset<armnnSerializer::PermuteDescriptor> descriptor = 0) {
5904 return builder_.
Finish();
5907 struct PermuteDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5909 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5913 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DIMMAPPINGS);
5915 bool Verify(flatbuffers::Verifier &verifier)
const {
5916 return VerifyTableStart(verifier) &&
5917 VerifyOffset(verifier, VT_DIMMAPPINGS) &&
5918 verifier.VerifyVector(dimMappings()) &&
5919 verifier.EndTable();
5925 flatbuffers::FlatBufferBuilder &
fbb_;
5928 fbb_.AddOffset(PermuteDescriptor::VT_DIMMAPPINGS, dimMappings);
5932 start_ = fbb_.StartTable();
5935 flatbuffers::Offset<PermuteDescriptor>
Finish() {
5936 const auto end = fbb_.EndTable(start_);
5937 auto o = flatbuffers::Offset<PermuteDescriptor>(end);
5943 flatbuffers::FlatBufferBuilder &_fbb,
5947 return builder_.
Finish();
5951 flatbuffers::FlatBufferBuilder &_fbb,
5952 const std::vector<uint32_t> *dimMappings =
nullptr) {
5953 auto dimMappings__ = dimMappings ? _fbb.CreateVector<uint32_t>(*dimMappings) : 0;
5959 struct ShapeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
5961 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5964 const armnnSerializer::LayerBase *
base()
const {
5965 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
5967 bool Verify(flatbuffers::Verifier &verifier)
const {
5968 return VerifyTableStart(verifier) &&
5969 VerifyOffset(verifier,
VT_BASE) &&
5970 verifier.VerifyTable(base()) &&
5971 verifier.EndTable();
5977 flatbuffers::FlatBufferBuilder &
fbb_;
5979 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
5984 start_ = fbb_.StartTable();
5988 const auto end = fbb_.EndTable(start_);
5989 auto o = flatbuffers::Offset<ShapeLayer>(end);
5995 flatbuffers::FlatBufferBuilder &_fbb,
5996 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
5999 return builder_.
Finish();
6002 struct SpaceToBatchNdLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6004 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6008 const armnnSerializer::LayerBase *
base()
const {
6009 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6011 const armnnSerializer::SpaceToBatchNdDescriptor *
descriptor()
const {
6012 return GetPointer<const armnnSerializer::SpaceToBatchNdDescriptor *>(
VT_DESCRIPTOR);
6014 bool Verify(flatbuffers::Verifier &verifier)
const {
6015 return VerifyTableStart(verifier) &&
6016 VerifyOffset(verifier,
VT_BASE) &&
6017 verifier.VerifyTable(base()) &&
6019 verifier.VerifyTable(descriptor()) &&
6020 verifier.EndTable();
6026 flatbuffers::FlatBufferBuilder &
fbb_;
6028 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6031 void add_descriptor(flatbuffers::Offset<armnnSerializer::SpaceToBatchNdDescriptor> descriptor) {
6036 start_ = fbb_.StartTable();
6039 flatbuffers::Offset<SpaceToBatchNdLayer>
Finish() {
6040 const auto end = fbb_.EndTable(start_);
6041 auto o = flatbuffers::Offset<SpaceToBatchNdLayer>(end);
6047 flatbuffers::FlatBufferBuilder &_fbb,
6048 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6049 flatbuffers::Offset<armnnSerializer::SpaceToBatchNdDescriptor> descriptor = 0) {
6053 return builder_.
Finish();
6056 struct SpaceToBatchNdDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6058 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6064 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_BLOCKSHAPE);
6066 const flatbuffers::Vector<uint32_t> *
padList()
const {
6067 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_PADLIST);
6072 bool Verify(flatbuffers::Verifier &verifier)
const {
6073 return VerifyTableStart(verifier) &&
6075 verifier.VerifyVector(blockShape()) &&
6077 verifier.VerifyVector(padList()) &&
6079 verifier.EndTable();
6085 flatbuffers::FlatBufferBuilder &
fbb_;
6098 start_ = fbb_.StartTable();
6101 flatbuffers::Offset<SpaceToBatchNdDescriptor>
Finish() {
6102 const auto end = fbb_.EndTable(start_);
6103 auto o = flatbuffers::Offset<SpaceToBatchNdDescriptor>(end);
6109 flatbuffers::FlatBufferBuilder &_fbb,
6117 return builder_.
Finish();
6121 flatbuffers::FlatBufferBuilder &_fbb,
6122 const std::vector<uint32_t> *blockShape =
nullptr,
6123 const std::vector<uint32_t> *padList =
nullptr,
6125 auto blockShape__ = blockShape ? _fbb.CreateVector<uint32_t>(*blockShape) : 0;
6126 auto padList__ = padList ? _fbb.CreateVector<uint32_t>(*padList) : 0;
6134 struct SpaceToDepthLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6136 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6140 const armnnSerializer::LayerBase *
base()
const {
6141 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6143 const armnnSerializer::SpaceToDepthDescriptor *
descriptor()
const {
6144 return GetPointer<const armnnSerializer::SpaceToDepthDescriptor *>(
VT_DESCRIPTOR);
6146 bool Verify(flatbuffers::Verifier &verifier)
const {
6147 return VerifyTableStart(verifier) &&
6148 VerifyOffset(verifier,
VT_BASE) &&
6149 verifier.VerifyTable(base()) &&
6151 verifier.VerifyTable(descriptor()) &&
6152 verifier.EndTable();
6158 flatbuffers::FlatBufferBuilder &
fbb_;
6160 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6163 void add_descriptor(flatbuffers::Offset<armnnSerializer::SpaceToDepthDescriptor> descriptor) {
6168 start_ = fbb_.StartTable();
6171 flatbuffers::Offset<SpaceToDepthLayer>
Finish() {
6172 const auto end = fbb_.EndTable(start_);
6173 auto o = flatbuffers::Offset<SpaceToDepthLayer>(end);
6179 flatbuffers::FlatBufferBuilder &_fbb,
6180 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6181 flatbuffers::Offset<armnnSerializer::SpaceToDepthDescriptor> descriptor = 0) {
6185 return builder_.
Finish();
6188 struct SpaceToDepthDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6190 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6200 bool Verify(flatbuffers::Verifier &verifier)
const {
6201 return VerifyTableStart(verifier) &&
6204 verifier.EndTable();
6210 flatbuffers::FlatBufferBuilder &
fbb_;
6220 start_ = fbb_.StartTable();
6223 flatbuffers::Offset<SpaceToDepthDescriptor>
Finish() {
6224 const auto end = fbb_.EndTable(start_);
6225 auto o = flatbuffers::Offset<SpaceToDepthDescriptor>(end);
6231 flatbuffers::FlatBufferBuilder &_fbb,
6232 uint32_t blockSize = 0,
6237 return builder_.
Finish();
6240 struct SubtractionLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6242 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6245 const armnnSerializer::LayerBase *
base()
const {
6246 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6248 bool Verify(flatbuffers::Verifier &verifier)
const {
6249 return VerifyTableStart(verifier) &&
6250 VerifyOffset(verifier,
VT_BASE) &&
6251 verifier.VerifyTable(base()) &&
6252 verifier.EndTable();
6258 flatbuffers::FlatBufferBuilder &
fbb_;
6260 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6265 start_ = fbb_.StartTable();
6268 flatbuffers::Offset<SubtractionLayer>
Finish() {
6269 const auto end = fbb_.EndTable(start_);
6270 auto o = flatbuffers::Offset<SubtractionLayer>(end);
6276 flatbuffers::FlatBufferBuilder &_fbb,
6277 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
6280 return builder_.
Finish();
6283 struct BatchToSpaceNdLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6285 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6289 const armnnSerializer::LayerBase *
base()
const {
6290 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6292 const armnnSerializer::BatchToSpaceNdDescriptor *
descriptor()
const {
6293 return GetPointer<const armnnSerializer::BatchToSpaceNdDescriptor *>(
VT_DESCRIPTOR);
6295 bool Verify(flatbuffers::Verifier &verifier)
const {
6296 return VerifyTableStart(verifier) &&
6297 VerifyOffset(verifier,
VT_BASE) &&
6298 verifier.VerifyTable(base()) &&
6300 verifier.VerifyTable(descriptor()) &&
6301 verifier.EndTable();
6307 flatbuffers::FlatBufferBuilder &
fbb_;
6309 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6312 void add_descriptor(flatbuffers::Offset<armnnSerializer::BatchToSpaceNdDescriptor> descriptor) {
6317 start_ = fbb_.StartTable();
6320 flatbuffers::Offset<BatchToSpaceNdLayer>
Finish() {
6321 const auto end = fbb_.EndTable(start_);
6322 auto o = flatbuffers::Offset<BatchToSpaceNdLayer>(end);
6328 flatbuffers::FlatBufferBuilder &_fbb,
6329 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6330 flatbuffers::Offset<armnnSerializer::BatchToSpaceNdDescriptor> descriptor = 0) {
6334 return builder_.
Finish();
6337 struct BatchToSpaceNdDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6339 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6345 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_BLOCKSHAPE);
6347 const flatbuffers::Vector<uint32_t> *
crops()
const {
6348 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_CROPS);
6353 bool Verify(flatbuffers::Verifier &verifier)
const {
6354 return VerifyTableStart(verifier) &&
6356 verifier.VerifyVector(blockShape()) &&
6357 VerifyOffset(verifier,
VT_CROPS) &&
6358 verifier.VerifyVector(crops()) &&
6360 verifier.EndTable();
6366 flatbuffers::FlatBufferBuilder &
fbb_;
6379 start_ = fbb_.StartTable();
6382 flatbuffers::Offset<BatchToSpaceNdDescriptor>
Finish() {
6383 const auto end = fbb_.EndTable(start_);
6384 auto o = flatbuffers::Offset<BatchToSpaceNdDescriptor>(end);
6390 flatbuffers::FlatBufferBuilder &_fbb,
6398 return builder_.
Finish();
6402 flatbuffers::FlatBufferBuilder &_fbb,
6403 const std::vector<uint32_t> *blockShape =
nullptr,
6404 const std::vector<uint32_t> *crops =
nullptr,
6406 auto blockShape__ = blockShape ? _fbb.CreateVector<uint32_t>(*blockShape) : 0;
6407 auto crops__ = crops ? _fbb.CreateVector<uint32_t>(*crops) : 0;
6415 struct NormalizationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6417 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6421 const armnnSerializer::LayerBase *
base()
const {
6422 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6424 const armnnSerializer::NormalizationDescriptor *
descriptor()
const {
6425 return GetPointer<const armnnSerializer::NormalizationDescriptor *>(
VT_DESCRIPTOR);
6427 bool Verify(flatbuffers::Verifier &verifier)
const {
6428 return VerifyTableStart(verifier) &&
6429 VerifyOffset(verifier,
VT_BASE) &&
6430 verifier.VerifyTable(base()) &&
6432 verifier.VerifyTable(descriptor()) &&
6433 verifier.EndTable();
6439 flatbuffers::FlatBufferBuilder &
fbb_;
6441 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6444 void add_descriptor(flatbuffers::Offset<armnnSerializer::NormalizationDescriptor> descriptor) {
6449 start_ = fbb_.StartTable();
6452 flatbuffers::Offset<NormalizationLayer>
Finish() {
6453 const auto end = fbb_.EndTable(start_);
6454 auto o = flatbuffers::Offset<NormalizationLayer>(end);
6460 flatbuffers::FlatBufferBuilder &_fbb,
6461 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6462 flatbuffers::Offset<armnnSerializer::NormalizationDescriptor> descriptor = 0) {
6466 return builder_.
Finish();
6469 struct NormalizationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6471 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6490 return GetField<float>(
VT_ALPHA, 0.0f);
6493 return GetField<float>(
VT_BETA, 0.0f);
6496 return GetField<float>(
VT_K, 0.0f);
6501 bool Verify(flatbuffers::Verifier &verifier)
const {
6502 return VerifyTableStart(verifier) &&
6506 VerifyField<float>(verifier,
VT_ALPHA) &&
6507 VerifyField<float>(verifier,
VT_BETA) &&
6508 VerifyField<float>(verifier,
VT_K) &&
6510 verifier.EndTable();
6516 flatbuffers::FlatBufferBuilder &
fbb_;
6541 start_ = fbb_.StartTable();
6544 flatbuffers::Offset<NormalizationDescriptor>
Finish() {
6545 const auto end = fbb_.EndTable(start_);
6546 auto o = flatbuffers::Offset<NormalizationDescriptor>(end);
6552 flatbuffers::FlatBufferBuilder &_fbb,
6555 uint32_t normSize = 0,
6568 return builder_.
Finish();
6571 struct MeanLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6573 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6577 const armnnSerializer::LayerBase *
base()
const {
6578 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6581 return GetPointer<const armnnSerializer::MeanDescriptor *>(
VT_DESCRIPTOR);
6583 bool Verify(flatbuffers::Verifier &verifier)
const {
6584 return VerifyTableStart(verifier) &&
6585 VerifyOffset(verifier,
VT_BASE) &&
6586 verifier.VerifyTable(base()) &&
6588 verifier.VerifyTable(descriptor()) &&
6589 verifier.EndTable();
6595 flatbuffers::FlatBufferBuilder &
fbb_;
6597 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6600 void add_descriptor(flatbuffers::Offset<armnnSerializer::MeanDescriptor> descriptor) {
6605 start_ = fbb_.StartTable();
6609 const auto end = fbb_.EndTable(start_);
6610 auto o = flatbuffers::Offset<MeanLayer>(end);
6616 flatbuffers::FlatBufferBuilder &_fbb,
6617 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6618 flatbuffers::Offset<armnnSerializer::MeanDescriptor> descriptor = 0) {
6622 return builder_.
Finish();
6625 struct MeanDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6627 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6631 const flatbuffers::Vector<uint32_t> *
axis()
const {
6632 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_AXIS);
6637 bool Verify(flatbuffers::Verifier &verifier)
const {
6638 return VerifyTableStart(verifier) &&
6639 VerifyOffset(verifier,
VT_AXIS) &&
6640 verifier.VerifyVector(axis()) &&
6642 verifier.EndTable();
6648 flatbuffers::FlatBufferBuilder &
fbb_;
6658 start_ = fbb_.StartTable();
6661 flatbuffers::Offset<MeanDescriptor>
Finish() {
6662 const auto end = fbb_.EndTable(start_);
6663 auto o = flatbuffers::Offset<MeanDescriptor>(end);
6669 flatbuffers::FlatBufferBuilder &_fbb,
6671 bool keepDims =
false) {
6675 return builder_.
Finish();
6679 flatbuffers::FlatBufferBuilder &_fbb,
6680 const std::vector<uint32_t> *axis =
nullptr,
6681 bool keepDims =
false) {
6682 auto axis__ = axis ? _fbb.CreateVector<uint32_t>(*axis) : 0;
6689 struct PadLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6691 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6695 const armnnSerializer::LayerBase *
base()
const {
6696 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6699 return GetPointer<const armnnSerializer::PadDescriptor *>(
VT_DESCRIPTOR);
6701 bool Verify(flatbuffers::Verifier &verifier)
const {
6702 return VerifyTableStart(verifier) &&
6703 VerifyOffset(verifier,
VT_BASE) &&
6704 verifier.VerifyTable(base()) &&
6706 verifier.VerifyTable(descriptor()) &&
6707 verifier.EndTable();
6713 flatbuffers::FlatBufferBuilder &
fbb_;
6715 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6718 void add_descriptor(flatbuffers::Offset<armnnSerializer::PadDescriptor> descriptor) {
6723 start_ = fbb_.StartTable();
6727 const auto end = fbb_.EndTable(start_);
6728 auto o = flatbuffers::Offset<PadLayer>(end);
6734 flatbuffers::FlatBufferBuilder &_fbb,
6735 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6736 flatbuffers::Offset<armnnSerializer::PadDescriptor> descriptor = 0) {
6740 return builder_.
Finish();
6743 struct PadDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6745 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6750 const flatbuffers::Vector<uint32_t> *
padList()
const {
6751 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_PADLIST);
6759 bool Verify(flatbuffers::Verifier &verifier)
const {
6760 return VerifyTableStart(verifier) &&
6762 verifier.VerifyVector(padList()) &&
6764 VerifyField<int8_t>(verifier, VT_PADDINGMODE) &&
6765 verifier.EndTable();
6771 flatbuffers::FlatBufferBuilder &
fbb_;
6780 fbb_.AddElement<int8_t>(PadDescriptor::VT_PADDINGMODE,
static_cast<int8_t
>(paddingMode), 0);
6784 start_ = fbb_.StartTable();
6787 flatbuffers::Offset<PadDescriptor>
Finish() {
6788 const auto end = fbb_.EndTable(start_);
6789 auto o = flatbuffers::Offset<PadDescriptor>(end);
6795 flatbuffers::FlatBufferBuilder &_fbb,
6797 float padValue = 0.0f,
6803 return builder_.
Finish();
6807 flatbuffers::FlatBufferBuilder &_fbb,
6808 const std::vector<uint32_t> *padList =
nullptr,
6809 float padValue = 0.0f,
6811 auto padList__ = padList ? _fbb.CreateVector<uint32_t>(*padList) : 0;
6820 struct RsqrtLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6822 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6825 const armnnSerializer::LayerBase *
base()
const {
6826 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6828 bool Verify(flatbuffers::Verifier &verifier)
const {
6829 return VerifyTableStart(verifier) &&
6830 VerifyOffset(verifier,
VT_BASE) &&
6831 verifier.VerifyTable(base()) &&
6832 verifier.EndTable();
6838 flatbuffers::FlatBufferBuilder &
fbb_;
6840 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6845 start_ = fbb_.StartTable();
6849 const auto end = fbb_.EndTable(start_);
6850 auto o = flatbuffers::Offset<RsqrtLayer>(end);
6856 flatbuffers::FlatBufferBuilder &_fbb,
6857 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
6860 return builder_.
Finish();
6863 struct BatchNormalizationLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6865 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6873 const armnnSerializer::LayerBase *
base()
const {
6874 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
6876 const armnnSerializer::BatchNormalizationDescriptor *
descriptor()
const {
6877 return GetPointer<const armnnSerializer::BatchNormalizationDescriptor *>(
VT_DESCRIPTOR);
6879 const armnnSerializer::ConstTensor *
mean()
const {
6880 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_MEAN);
6883 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_VARIANCE);
6885 const armnnSerializer::ConstTensor *
beta()
const {
6886 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_BETA);
6888 const armnnSerializer::ConstTensor *
gamma()
const {
6889 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_GAMMA);
6891 bool Verify(flatbuffers::Verifier &verifier)
const {
6892 return VerifyTableStart(verifier) &&
6893 VerifyOffset(verifier,
VT_BASE) &&
6894 verifier.VerifyTable(base()) &&
6896 verifier.VerifyTable(descriptor()) &&
6897 VerifyOffset(verifier,
VT_MEAN) &&
6898 verifier.VerifyTable(mean()) &&
6900 verifier.VerifyTable(variance()) &&
6901 VerifyOffset(verifier,
VT_BETA) &&
6902 verifier.VerifyTable(beta()) &&
6903 VerifyOffset(verifier,
VT_GAMMA) &&
6904 verifier.VerifyTable(gamma()) &&
6905 verifier.EndTable();
6911 flatbuffers::FlatBufferBuilder &
fbb_;
6913 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
6916 void add_descriptor(flatbuffers::Offset<armnnSerializer::BatchNormalizationDescriptor> descriptor) {
6919 void add_mean(flatbuffers::Offset<armnnSerializer::ConstTensor> mean) {
6922 void add_variance(flatbuffers::Offset<armnnSerializer::ConstTensor> variance) {
6925 void add_beta(flatbuffers::Offset<armnnSerializer::ConstTensor> beta) {
6928 void add_gamma(flatbuffers::Offset<armnnSerializer::ConstTensor> gamma) {
6933 start_ = fbb_.StartTable();
6936 flatbuffers::Offset<BatchNormalizationLayer>
Finish() {
6937 const auto end = fbb_.EndTable(start_);
6938 auto o = flatbuffers::Offset<BatchNormalizationLayer>(end);
6944 flatbuffers::FlatBufferBuilder &_fbb,
6945 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
6946 flatbuffers::Offset<armnnSerializer::BatchNormalizationDescriptor> descriptor = 0,
6947 flatbuffers::Offset<armnnSerializer::ConstTensor> mean = 0,
6948 flatbuffers::Offset<armnnSerializer::ConstTensor> variance = 0,
6949 flatbuffers::Offset<armnnSerializer::ConstTensor> beta = 0,
6950 flatbuffers::Offset<armnnSerializer::ConstTensor> gamma = 0) {
6958 return builder_.
Finish();
6961 struct BatchNormalizationDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
6963 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6968 return GetField<float>(
VT_EPS, 0.0f);
6973 bool Verify(flatbuffers::Verifier &verifier)
const {
6974 return VerifyTableStart(verifier) &&
6975 VerifyField<float>(verifier,
VT_EPS) &&
6977 verifier.EndTable();
6982 typedef BatchNormalizationDescriptor
Table;
6983 flatbuffers::FlatBufferBuilder &
fbb_;
6993 start_ = fbb_.StartTable();
6996 flatbuffers::Offset<BatchNormalizationDescriptor>
Finish() {
6997 const auto end = fbb_.EndTable(start_);
6998 auto o = flatbuffers::Offset<BatchNormalizationDescriptor>(end);
7004 flatbuffers::FlatBufferBuilder &_fbb,
7010 return builder_.
Finish();
7014 struct ResizeBilinearLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7016 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7020 const armnnSerializer::LayerBase *
base()
const {
7021 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
7023 const armnnSerializer::ResizeBilinearDescriptor *
descriptor()
const {
7024 return GetPointer<const armnnSerializer::ResizeBilinearDescriptor *>(
VT_DESCRIPTOR);
7026 bool Verify(flatbuffers::Verifier &verifier)
const {
7027 return VerifyTableStart(verifier) &&
7028 VerifyOffset(verifier,
VT_BASE) &&
7029 verifier.VerifyTable(base()) &&
7031 verifier.VerifyTable(descriptor()) &&
7032 verifier.EndTable();
7038 flatbuffers::FlatBufferBuilder &
fbb_;
7040 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
7043 void add_descriptor(flatbuffers::Offset<armnnSerializer::ResizeBilinearDescriptor> descriptor) {
7048 start_ = fbb_.StartTable();
7051 flatbuffers::Offset<ResizeBilinearLayer>
Finish() {
7052 const auto end = fbb_.EndTable(start_);
7053 auto o = flatbuffers::Offset<ResizeBilinearLayer>(end);
7059 flatbuffers::FlatBufferBuilder &_fbb,
7060 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7061 flatbuffers::Offset<armnnSerializer::ResizeBilinearDescriptor> descriptor = 0) {
7065 return builder_.
Finish();
7068 struct ResizeBilinearDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7070 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7075 VT_HALFPIXELCENTERS = 12
7090 return GetField<uint8_t>(VT_HALFPIXELCENTERS, 0) != 0;
7092 bool Verify(flatbuffers::Verifier &verifier)
const {
7093 return VerifyTableStart(verifier) &&
7098 VerifyField<uint8_t>(verifier, VT_HALFPIXELCENTERS) &&
7099 verifier.EndTable();
7105 flatbuffers::FlatBufferBuilder &
fbb_;
7120 fbb_.AddElement<uint8_t>(ResizeBilinearDescriptor::VT_HALFPIXELCENTERS,
static_cast<uint8_t
>(halfPixelCenters), 0);
7124 start_ = fbb_.StartTable();
7127 flatbuffers::Offset<ResizeBilinearDescriptor>
Finish() {
7128 const auto end = fbb_.EndTable(start_);
7129 auto o = flatbuffers::Offset<ResizeBilinearDescriptor>(end);
7135 flatbuffers::FlatBufferBuilder &_fbb,
7136 uint32_t targetWidth = 0,
7137 uint32_t targetHeight = 0,
7139 bool alignCorners =
false,
7140 bool halfPixelCenters =
false) {
7147 return builder_.
Finish();
7150 struct SliceLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7152 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7156 const armnnSerializer::LayerBase *
base()
const {
7157 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
7160 return GetPointer<const armnnSerializer::SliceDescriptor *>(
VT_DESCRIPTOR);
7162 bool Verify(flatbuffers::Verifier &verifier)
const {
7163 return VerifyTableStart(verifier) &&
7164 VerifyOffset(verifier,
VT_BASE) &&
7165 verifier.VerifyTable(base()) &&
7167 verifier.VerifyTable(descriptor()) &&
7168 verifier.EndTable();
7174 flatbuffers::FlatBufferBuilder &
fbb_;
7176 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
7179 void add_descriptor(flatbuffers::Offset<armnnSerializer::SliceDescriptor> descriptor) {
7184 start_ = fbb_.StartTable();
7188 const auto end = fbb_.EndTable(start_);
7189 auto o = flatbuffers::Offset<SliceLayer>(end);
7195 flatbuffers::FlatBufferBuilder &_fbb,
7196 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7197 flatbuffers::Offset<armnnSerializer::SliceDescriptor> descriptor = 0) {
7201 return builder_.
Finish();
7204 struct SliceDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7206 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7210 const flatbuffers::Vector<uint32_t> *
begin()
const {
7211 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_BEGIN);
7213 const flatbuffers::Vector<uint32_t> *
size()
const {
7214 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_SIZE);
7216 bool Verify(flatbuffers::Verifier &verifier)
const {
7217 return VerifyTableStart(verifier) &&
7218 VerifyOffset(verifier,
VT_BEGIN) &&
7219 verifier.VerifyVector(begin()) &&
7220 VerifyOffset(verifier, VT_SIZE) &&
7221 verifier.VerifyVector(size()) &&
7222 verifier.EndTable();
7228 flatbuffers::FlatBufferBuilder &
fbb_;
7234 fbb_.AddOffset(SliceDescriptor::VT_SIZE, size);
7238 start_ = fbb_.StartTable();
7241 flatbuffers::Offset<SliceDescriptor>
Finish() {
7242 const auto end = fbb_.EndTable(start_);
7243 auto o = flatbuffers::Offset<SliceDescriptor>(end);
7249 flatbuffers::FlatBufferBuilder &_fbb,
7255 return builder_.
Finish();
7259 flatbuffers::FlatBufferBuilder &_fbb,
7260 const std::vector<uint32_t> *begin =
nullptr,
7261 const std::vector<uint32_t> *size =
nullptr) {
7262 auto begin__ = begin ? _fbb.CreateVector<uint32_t>(*begin) : 0;
7263 auto size__ = size ? _fbb.CreateVector<uint32_t>(*size) : 0;
7270 struct StridedSliceLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7272 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7276 const armnnSerializer::LayerBase *
base()
const {
7277 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
7279 const armnnSerializer::StridedSliceDescriptor *
descriptor()
const {
7280 return GetPointer<const armnnSerializer::StridedSliceDescriptor *>(
VT_DESCRIPTOR);
7282 bool Verify(flatbuffers::Verifier &verifier)
const {
7283 return VerifyTableStart(verifier) &&
7284 VerifyOffset(verifier,
VT_BASE) &&
7285 verifier.VerifyTable(base()) &&
7287 verifier.VerifyTable(descriptor()) &&
7288 verifier.EndTable();
7294 flatbuffers::FlatBufferBuilder &
fbb_;
7296 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
7299 void add_descriptor(flatbuffers::Offset<armnnSerializer::StridedSliceDescriptor> descriptor) {
7304 start_ = fbb_.StartTable();
7307 flatbuffers::Offset<StridedSliceLayer>
Finish() {
7308 const auto end = fbb_.EndTable(start_);
7309 auto o = flatbuffers::Offset<StridedSliceLayer>(end);
7315 flatbuffers::FlatBufferBuilder &_fbb,
7316 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7317 flatbuffers::Offset<armnnSerializer::StridedSliceDescriptor> descriptor = 0) {
7321 return builder_.
Finish();
7324 struct StridedSliceDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7326 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7337 const flatbuffers::Vector<int32_t> *
begin()
const {
7338 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_BEGIN);
7340 const flatbuffers::Vector<int32_t> *
end()
const {
7341 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_END);
7343 const flatbuffers::Vector<int32_t> *
stride()
const {
7344 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_STRIDE);
7364 bool Verify(flatbuffers::Verifier &verifier)
const {
7365 return VerifyTableStart(verifier) &&
7366 VerifyOffset(verifier,
VT_BEGIN) &&
7367 verifier.VerifyVector(begin()) &&
7368 VerifyOffset(verifier,
VT_END) &&
7369 verifier.VerifyVector(end()) &&
7371 verifier.VerifyVector(stride()) &&
7373 VerifyField<int32_t>(verifier,
VT_ENDMASK) &&
7378 verifier.EndTable();
7384 flatbuffers::FlatBufferBuilder &
fbb_;
7415 start_ = fbb_.StartTable();
7418 flatbuffers::Offset<StridedSliceDescriptor>
Finish() {
7419 const auto end = fbb_.EndTable(start_);
7420 auto o = flatbuffers::Offset<StridedSliceDescriptor>(end);
7426 flatbuffers::FlatBufferBuilder &_fbb,
7430 int32_t beginMask = 0,
7431 int32_t endMask = 0,
7432 int32_t shrinkAxisMask = 0,
7433 int32_t ellipsisMask = 0,
7434 int32_t newAxisMask = 0,
7446 return builder_.
Finish();
7450 flatbuffers::FlatBufferBuilder &_fbb,
7451 const std::vector<int32_t> *begin =
nullptr,
7452 const std::vector<int32_t> *end =
nullptr,
7453 const std::vector<int32_t> *stride =
nullptr,
7454 int32_t beginMask = 0,
7455 int32_t endMask = 0,
7456 int32_t shrinkAxisMask = 0,
7457 int32_t ellipsisMask = 0,
7458 int32_t newAxisMask = 0,
7460 auto begin__ = begin ? _fbb.CreateVector<int32_t>(*begin) : 0;
7461 auto end__ = end ? _fbb.CreateVector<int32_t>(*end) : 0;
7462 auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0;
7476 struct ConcatLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7478 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7482 const armnnSerializer::LayerBase *
base()
const {
7483 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
7486 return GetPointer<const armnnSerializer::OriginsDescriptor *>(
VT_DESCRIPTOR);
7488 bool Verify(flatbuffers::Verifier &verifier)
const {
7489 return VerifyTableStart(verifier) &&
7490 VerifyOffset(verifier,
VT_BASE) &&
7491 verifier.VerifyTable(base()) &&
7493 verifier.VerifyTable(descriptor()) &&
7494 verifier.EndTable();
7500 flatbuffers::FlatBufferBuilder &
fbb_;
7502 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
7505 void add_descriptor(flatbuffers::Offset<armnnSerializer::OriginsDescriptor> descriptor) {
7510 start_ = fbb_.StartTable();
7514 const auto end = fbb_.EndTable(start_);
7515 auto o = flatbuffers::Offset<ConcatLayer>(end);
7521 flatbuffers::FlatBufferBuilder &_fbb,
7522 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7523 flatbuffers::Offset<armnnSerializer::OriginsDescriptor> descriptor = 0) {
7527 return builder_.
Finish();
7531 struct MergerLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7533 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7537 const armnnSerializer::LayerBase *
base()
const {
7538 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
7541 return GetPointer<const armnnSerializer::OriginsDescriptor *>(
VT_DESCRIPTOR);
7543 bool Verify(flatbuffers::Verifier &verifier)
const {
7544 return VerifyTableStart(verifier) &&
7545 VerifyOffset(verifier,
VT_BASE) &&
7546 verifier.VerifyTable(base()) &&
7548 verifier.VerifyTable(descriptor()) &&
7549 verifier.EndTable();
7555 flatbuffers::FlatBufferBuilder &
fbb_;
7557 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
7560 void add_descriptor(flatbuffers::Offset<armnnSerializer::OriginsDescriptor> descriptor) {
7565 start_ = fbb_.StartTable();
7569 const auto end = fbb_.EndTable(start_);
7570 auto o = flatbuffers::Offset<MergerLayer>(end);
7576 flatbuffers::FlatBufferBuilder &_fbb,
7577 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7578 flatbuffers::Offset<armnnSerializer::OriginsDescriptor> descriptor = 0) {
7582 return builder_.
Finish();
7585 struct UintVector FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7587 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7590 const flatbuffers::Vector<uint32_t> *
data()
const {
7591 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DATA);
7593 bool Verify(flatbuffers::Verifier &verifier)
const {
7594 return VerifyTableStart(verifier) &&
7595 VerifyOffset(verifier, VT_DATA) &&
7596 verifier.VerifyVector(data()) &&
7597 verifier.EndTable();
7603 flatbuffers::FlatBufferBuilder &
fbb_;
7606 fbb_.AddOffset(UintVector::VT_DATA, data);
7610 start_ = fbb_.StartTable();
7614 const auto end = fbb_.EndTable(start_);
7615 auto o = flatbuffers::Offset<UintVector>(end);
7621 flatbuffers::FlatBufferBuilder &_fbb,
7625 return builder_.
Finish();
7629 flatbuffers::FlatBufferBuilder &_fbb,
7630 const std::vector<uint32_t> *data =
nullptr) {
7631 auto data__ = data ? _fbb.CreateVector<uint32_t>(*data) : 0;
7637 struct OriginsDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7639 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7654 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>> *
viewOrigins()
const {
7655 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>> *>(VT_VIEWORIGINS);
7657 bool Verify(flatbuffers::Verifier &verifier)
const {
7658 return VerifyTableStart(verifier) &&
7662 VerifyOffset(verifier, VT_VIEWORIGINS) &&
7663 verifier.VerifyVector(viewOrigins()) &&
7664 verifier.VerifyVectorOfTables(viewOrigins()) &&
7665 verifier.EndTable();
7671 flatbuffers::FlatBufferBuilder &
fbb_;
7683 fbb_.AddOffset(OriginsDescriptor::VT_VIEWORIGINS, viewOrigins);
7687 start_ = fbb_.StartTable();
7690 flatbuffers::Offset<OriginsDescriptor>
Finish() {
7691 const auto end = fbb_.EndTable(start_);
7692 auto o = flatbuffers::Offset<OriginsDescriptor>(end);
7698 flatbuffers::FlatBufferBuilder &_fbb,
7699 uint32_t concatAxis = 0,
7700 uint32_t numViews = 0,
7701 uint32_t numDimensions = 0,
7702 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>>> viewOrigins = 0) {
7708 return builder_.
Finish();
7712 flatbuffers::FlatBufferBuilder &_fbb,
7713 uint32_t concatAxis = 0,
7714 uint32_t numViews = 0,
7715 uint32_t numDimensions = 0,
7716 const std::vector<flatbuffers::Offset<armnnSerializer::UintVector>> *viewOrigins =
nullptr) {
7717 auto viewOrigins__ = viewOrigins ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::UintVector>>(*viewOrigins) : 0;
7726 struct ViewsDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7728 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7732 const armnnSerializer::OriginsDescriptor *
origins()
const {
7733 return GetPointer<const armnnSerializer::OriginsDescriptor *>(
VT_ORIGINS);
7735 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>> *
viewSizes()
const {
7736 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>> *>(VT_VIEWSIZES);
7738 bool Verify(flatbuffers::Verifier &verifier)
const {
7739 return VerifyTableStart(verifier) &&
7741 verifier.VerifyTable(origins()) &&
7742 VerifyOffset(verifier, VT_VIEWSIZES) &&
7743 verifier.VerifyVector(viewSizes()) &&
7744 verifier.VerifyVectorOfTables(viewSizes()) &&
7745 verifier.EndTable();
7751 flatbuffers::FlatBufferBuilder &
fbb_;
7753 void add_origins(flatbuffers::Offset<armnnSerializer::OriginsDescriptor> origins) {
7757 fbb_.AddOffset(ViewsDescriptor::VT_VIEWSIZES, viewSizes);
7761 start_ = fbb_.StartTable();
7764 flatbuffers::Offset<ViewsDescriptor>
Finish() {
7765 const auto end = fbb_.EndTable(start_);
7766 auto o = flatbuffers::Offset<ViewsDescriptor>(end);
7772 flatbuffers::FlatBufferBuilder &_fbb,
7773 flatbuffers::Offset<armnnSerializer::OriginsDescriptor> origins = 0,
7774 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::UintVector>>> viewSizes = 0) {
7778 return builder_.
Finish();
7782 flatbuffers::FlatBufferBuilder &_fbb,
7783 flatbuffers::Offset<armnnSerializer::OriginsDescriptor> origins = 0,
7784 const std::vector<flatbuffers::Offset<armnnSerializer::UintVector>> *viewSizes =
nullptr) {
7785 auto viewSizes__ = viewSizes ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::UintVector>>(*viewSizes) : 0;
7792 struct SplitterLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7794 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7798 const armnnSerializer::LayerBase *
base()
const {
7799 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
7802 return GetPointer<const armnnSerializer::ViewsDescriptor *>(
VT_DESCRIPTOR);
7804 bool Verify(flatbuffers::Verifier &verifier)
const {
7805 return VerifyTableStart(verifier) &&
7806 VerifyOffset(verifier,
VT_BASE) &&
7807 verifier.VerifyTable(base()) &&
7809 verifier.VerifyTable(descriptor()) &&
7810 verifier.EndTable();
7816 flatbuffers::FlatBufferBuilder &
fbb_;
7818 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
7821 void add_descriptor(flatbuffers::Offset<armnnSerializer::ViewsDescriptor> descriptor) {
7826 start_ = fbb_.StartTable();
7829 flatbuffers::Offset<SplitterLayer>
Finish() {
7830 const auto end = fbb_.EndTable(start_);
7831 auto o = flatbuffers::Offset<SplitterLayer>(end);
7837 flatbuffers::FlatBufferBuilder &_fbb,
7838 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7839 flatbuffers::Offset<armnnSerializer::ViewsDescriptor> descriptor = 0) {
7843 return builder_.
Finish();
7846 struct DetectionPostProcessLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7848 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7853 const armnnSerializer::LayerBase *
base()
const {
7854 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
7856 const armnnSerializer::DetectionPostProcessDescriptor *
descriptor()
const {
7857 return GetPointer<const armnnSerializer::DetectionPostProcessDescriptor *>(
VT_DESCRIPTOR);
7859 const armnnSerializer::ConstTensor *
anchors()
const {
7860 return GetPointer<const armnnSerializer::ConstTensor *>(VT_ANCHORS);
7862 bool Verify(flatbuffers::Verifier &verifier)
const {
7863 return VerifyTableStart(verifier) &&
7864 VerifyOffset(verifier,
VT_BASE) &&
7865 verifier.VerifyTable(base()) &&
7867 verifier.VerifyTable(descriptor()) &&
7868 VerifyOffset(verifier, VT_ANCHORS) &&
7869 verifier.VerifyTable(anchors()) &&
7870 verifier.EndTable();
7875 typedef DetectionPostProcessLayer
Table;
7876 flatbuffers::FlatBufferBuilder &
fbb_;
7878 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
7881 void add_descriptor(flatbuffers::Offset<armnnSerializer::DetectionPostProcessDescriptor> descriptor) {
7884 void add_anchors(flatbuffers::Offset<armnnSerializer::ConstTensor> anchors) {
7885 fbb_.AddOffset(DetectionPostProcessLayer::VT_ANCHORS, anchors);
7889 start_ = fbb_.StartTable();
7892 flatbuffers::Offset<DetectionPostProcessLayer>
Finish() {
7893 const auto end = fbb_.EndTable(start_);
7894 auto o = flatbuffers::Offset<DetectionPostProcessLayer>(end);
7900 flatbuffers::FlatBufferBuilder &_fbb,
7901 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
7902 flatbuffers::Offset<armnnSerializer::DetectionPostProcessDescriptor> descriptor = 0,
7903 flatbuffers::Offset<armnnSerializer::ConstTensor> anchors = 0) {
7908 return builder_.
Finish();
7911 struct DetectionPostProcessDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
7913 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7948 return GetField<float>(
VT_SCALEX, 0.0f);
7951 return GetField<float>(
VT_SCALEY, 0.0f);
7954 return GetField<float>(
VT_SCALEW, 0.0f);
7957 return GetField<float>(VT_SCALEH, 0.0f);
7959 bool Verify(flatbuffers::Verifier &verifier)
const {
7960 return VerifyTableStart(verifier) &&
7968 VerifyField<float>(verifier,
VT_SCALEX) &&
7969 VerifyField<float>(verifier,
VT_SCALEY) &&
7970 VerifyField<float>(verifier,
VT_SCALEW) &&
7971 VerifyField<float>(verifier, VT_SCALEH) &&
7972 verifier.EndTable();
7977 typedef DetectionPostProcessDescriptor
Table;
7978 flatbuffers::FlatBufferBuilder &
fbb_;
8011 fbb_.AddElement<
float>(DetectionPostProcessDescriptor::VT_SCALEH, scaleH, 0.0f);
8015 start_ = fbb_.StartTable();
8018 flatbuffers::Offset<DetectionPostProcessDescriptor>
Finish() {
8019 const auto end = fbb_.EndTable(start_);
8020 auto o = flatbuffers::Offset<DetectionPostProcessDescriptor>(end);
8026 flatbuffers::FlatBufferBuilder &_fbb,
8027 uint32_t maxDetections = 0,
8028 uint32_t maxClassesPerDetection = 0,
8029 uint32_t detectionsPerClass = 0,
8030 float nmsScoreThreshold = 0.0f,
8031 float nmsIouThreshold = 0.0f,
8032 uint32_t numClasses = 0,
8033 bool useRegularNms =
false,
8034 float scaleX = 0.0f,
8035 float scaleY = 0.0f,
8036 float scaleW = 0.0f,
8037 float scaleH = 0.0f) {
8050 return builder_.
Finish();
8053 struct LstmInputParams FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8055 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8076 VT_OUTPUTLAYERNORMWEIGHTS = 44
8100 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_CELLBIAS);
8139 return GetPointer<const armnnSerializer::ConstTensor *>(VT_OUTPUTLAYERNORMWEIGHTS);
8141 bool Verify(flatbuffers::Verifier &verifier)
const {
8142 return VerifyTableStart(verifier) &&
8144 verifier.VerifyTable(inputToForgetWeights()) &&
8146 verifier.VerifyTable(inputToCellWeights()) &&
8148 verifier.VerifyTable(inputToOutputWeights()) &&
8150 verifier.VerifyTable(recurrentToForgetWeights()) &&
8152 verifier.VerifyTable(recurrentToCellWeights()) &&
8154 verifier.VerifyTable(recurrentToOutputWeights()) &&
8156 verifier.VerifyTable(forgetGateBias()) &&
8158 verifier.VerifyTable(cellBias()) &&
8160 verifier.VerifyTable(outputGateBias()) &&
8162 verifier.VerifyTable(inputToInputWeights()) &&
8164 verifier.VerifyTable(recurrentToInputWeights()) &&
8166 verifier.VerifyTable(cellToInputWeights()) &&
8168 verifier.VerifyTable(inputGateBias()) &&
8170 verifier.VerifyTable(projectionWeights()) &&
8172 verifier.VerifyTable(projectionBias()) &&
8174 verifier.VerifyTable(cellToForgetWeights()) &&
8176 verifier.VerifyTable(cellToOutputWeights()) &&
8178 verifier.VerifyTable(inputLayerNormWeights()) &&
8180 verifier.VerifyTable(forgetLayerNormWeights()) &&
8182 verifier.VerifyTable(cellLayerNormWeights()) &&
8183 VerifyOffset(verifier, VT_OUTPUTLAYERNORMWEIGHTS) &&
8184 verifier.VerifyTable(outputLayerNormWeights()) &&
8185 verifier.EndTable();
8191 flatbuffers::FlatBufferBuilder &
fbb_;
8214 void add_cellBias(flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias) {
8254 fbb_.AddOffset(LstmInputParams::VT_OUTPUTLAYERNORMWEIGHTS, outputLayerNormWeights);
8258 start_ = fbb_.StartTable();
8261 flatbuffers::Offset<LstmInputParams>
Finish() {
8262 const auto end = fbb_.EndTable(start_);
8263 auto o = flatbuffers::Offset<LstmInputParams>(end);
8269 flatbuffers::FlatBufferBuilder &_fbb,
8270 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToForgetWeights = 0,
8271 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToCellWeights = 0,
8272 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToOutputWeights = 0,
8273 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToForgetWeights = 0,
8274 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToCellWeights = 0,
8275 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToOutputWeights = 0,
8276 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetGateBias = 0,
8277 flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias = 0,
8278 flatbuffers::Offset<armnnSerializer::ConstTensor> outputGateBias = 0,
8279 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToInputWeights = 0,
8280 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToInputWeights = 0,
8281 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToInputWeights = 0,
8282 flatbuffers::Offset<armnnSerializer::ConstTensor> inputGateBias = 0,
8283 flatbuffers::Offset<armnnSerializer::ConstTensor> projectionWeights = 0,
8284 flatbuffers::Offset<armnnSerializer::ConstTensor> projectionBias = 0,
8285 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToForgetWeights = 0,
8286 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToOutputWeights = 0,
8287 flatbuffers::Offset<armnnSerializer::ConstTensor> inputLayerNormWeights = 0,
8288 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetLayerNormWeights = 0,
8289 flatbuffers::Offset<armnnSerializer::ConstTensor> cellLayerNormWeights = 0,
8290 flatbuffers::Offset<armnnSerializer::ConstTensor> outputLayerNormWeights = 0) {
8313 return builder_.
Finish();
8316 struct LstmDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8318 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8348 bool Verify(flatbuffers::Verifier &verifier)
const {
8349 return VerifyTableStart(verifier) &&
8357 verifier.EndTable();
8363 flatbuffers::FlatBufferBuilder &
fbb_;
8388 start_ = fbb_.StartTable();
8391 flatbuffers::Offset<LstmDescriptor>
Finish() {
8392 const auto end = fbb_.EndTable(start_);
8393 auto o = flatbuffers::Offset<LstmDescriptor>(end);
8399 flatbuffers::FlatBufferBuilder &_fbb,
8400 uint32_t activationFunc = 0,
8401 float clippingThresCell = 0.0f,
8402 float clippingThresProj = 0.0f,
8403 bool cifgEnabled =
true,
8404 bool peepholeEnabled =
false,
8405 bool projectionEnabled =
false,
8406 bool layerNormEnabled =
false) {
8415 return builder_.
Finish();
8418 struct LstmLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8420 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8425 const armnnSerializer::LayerBase *
base()
const {
8426 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8429 return GetPointer<const armnnSerializer::LstmDescriptor *>(
VT_DESCRIPTOR);
8432 return GetPointer<const armnnSerializer::LstmInputParams *>(VT_INPUTPARAMS);
8434 bool Verify(flatbuffers::Verifier &verifier)
const {
8435 return VerifyTableStart(verifier) &&
8436 VerifyOffset(verifier,
VT_BASE) &&
8437 verifier.VerifyTable(base()) &&
8439 verifier.VerifyTable(descriptor()) &&
8440 VerifyOffset(verifier, VT_INPUTPARAMS) &&
8441 verifier.VerifyTable(inputParams()) &&
8442 verifier.EndTable();
8448 flatbuffers::FlatBufferBuilder &
fbb_;
8450 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8453 void add_descriptor(flatbuffers::Offset<armnnSerializer::LstmDescriptor> descriptor) {
8457 fbb_.AddOffset(LstmLayer::VT_INPUTPARAMS, inputParams);
8461 start_ = fbb_.StartTable();
8465 const auto end = fbb_.EndTable(start_);
8466 auto o = flatbuffers::Offset<LstmLayer>(end);
8472 flatbuffers::FlatBufferBuilder &_fbb,
8473 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
8474 flatbuffers::Offset<armnnSerializer::LstmDescriptor> descriptor = 0,
8475 flatbuffers::Offset<armnnSerializer::LstmInputParams> inputParams = 0) {
8480 return builder_.
Finish();
8483 struct QLstmInputParams FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8485 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8506 VT_OUTPUTLAYERNORMWEIGHTS = 44
8530 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_CELLBIAS);
8569 return GetPointer<const armnnSerializer::ConstTensor *>(VT_OUTPUTLAYERNORMWEIGHTS);
8571 bool Verify(flatbuffers::Verifier &verifier)
const {
8572 return VerifyTableStart(verifier) &&
8574 verifier.VerifyTable(inputToForgetWeights()) &&
8576 verifier.VerifyTable(inputToCellWeights()) &&
8578 verifier.VerifyTable(inputToOutputWeights()) &&
8580 verifier.VerifyTable(recurrentToForgetWeights()) &&
8582 verifier.VerifyTable(recurrentToCellWeights()) &&
8584 verifier.VerifyTable(recurrentToOutputWeights()) &&
8586 verifier.VerifyTable(forgetGateBias()) &&
8588 verifier.VerifyTable(cellBias()) &&
8590 verifier.VerifyTable(outputGateBias()) &&
8592 verifier.VerifyTable(inputToInputWeights()) &&
8594 verifier.VerifyTable(recurrentToInputWeights()) &&
8596 verifier.VerifyTable(inputGateBias()) &&
8598 verifier.VerifyTable(projectionWeights()) &&
8600 verifier.VerifyTable(projectionBias()) &&
8602 verifier.VerifyTable(cellToInputWeights()) &&
8604 verifier.VerifyTable(cellToForgetWeights()) &&
8606 verifier.VerifyTable(cellToOutputWeights()) &&
8608 verifier.VerifyTable(inputLayerNormWeights()) &&
8610 verifier.VerifyTable(forgetLayerNormWeights()) &&
8612 verifier.VerifyTable(cellLayerNormWeights()) &&
8613 VerifyOffset(verifier, VT_OUTPUTLAYERNORMWEIGHTS) &&
8614 verifier.VerifyTable(outputLayerNormWeights()) &&
8615 verifier.EndTable();
8621 flatbuffers::FlatBufferBuilder &
fbb_;
8644 void add_cellBias(flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias) {
8684 fbb_.AddOffset(QLstmInputParams::VT_OUTPUTLAYERNORMWEIGHTS, outputLayerNormWeights);
8688 start_ = fbb_.StartTable();
8691 flatbuffers::Offset<QLstmInputParams>
Finish() {
8692 const auto end = fbb_.EndTable(start_);
8693 auto o = flatbuffers::Offset<QLstmInputParams>(end);
8699 flatbuffers::FlatBufferBuilder &_fbb,
8700 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToForgetWeights = 0,
8701 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToCellWeights = 0,
8702 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToOutputWeights = 0,
8703 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToForgetWeights = 0,
8704 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToCellWeights = 0,
8705 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToOutputWeights = 0,
8706 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetGateBias = 0,
8707 flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias = 0,
8708 flatbuffers::Offset<armnnSerializer::ConstTensor> outputGateBias = 0,
8709 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToInputWeights = 0,
8710 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToInputWeights = 0,
8711 flatbuffers::Offset<armnnSerializer::ConstTensor> inputGateBias = 0,
8712 flatbuffers::Offset<armnnSerializer::ConstTensor> projectionWeights = 0,
8713 flatbuffers::Offset<armnnSerializer::ConstTensor> projectionBias = 0,
8714 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToInputWeights = 0,
8715 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToForgetWeights = 0,
8716 flatbuffers::Offset<armnnSerializer::ConstTensor> cellToOutputWeights = 0,
8717 flatbuffers::Offset<armnnSerializer::ConstTensor> inputLayerNormWeights = 0,
8718 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetLayerNormWeights = 0,
8719 flatbuffers::Offset<armnnSerializer::ConstTensor> cellLayerNormWeights = 0,
8720 flatbuffers::Offset<armnnSerializer::ConstTensor> outputLayerNormWeights = 0) {
8743 return builder_.
Finish();
8746 struct QLstmDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8748 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8760 VT_HIDDENSTATESCALE = 26
8796 return GetField<float>(VT_HIDDENSTATESCALE, 0.0f);
8798 bool Verify(flatbuffers::Verifier &verifier)
const {
8799 return VerifyTableStart(verifier) &&
8811 VerifyField<float>(verifier, VT_HIDDENSTATESCALE) &&
8812 verifier.EndTable();
8818 flatbuffers::FlatBufferBuilder &
fbb_;
8854 fbb_.AddElement<
float>(QLstmDescriptor::VT_HIDDENSTATESCALE, hiddenStateScale, 0.0f);
8858 start_ = fbb_.StartTable();
8861 flatbuffers::Offset<QLstmDescriptor>
Finish() {
8862 const auto end = fbb_.EndTable(start_);
8863 auto o = flatbuffers::Offset<QLstmDescriptor>(end);
8869 flatbuffers::FlatBufferBuilder &_fbb,
8870 bool cifgEnabled =
true,
8871 bool peepholeEnabled =
false,
8872 bool projectionEnabled =
false,
8873 bool layerNormEnabled =
false,
8874 float cellClip = 0.0f,
8875 float projectionClip = 0.0f,
8876 float inputIntermediateScale = 0.0f,
8877 float forgetIntermediateScale = 0.0f,
8878 float cellIntermediateScale = 0.0f,
8879 float outputIntermediateScale = 0.0f,
8880 int32_t hiddenStateZeroPoint = 0,
8881 float hiddenStateScale = 0.0f) {
8895 return builder_.
Finish();
8898 struct QLstmLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8900 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8905 const armnnSerializer::LayerBase *
base()
const {
8906 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
8909 return GetPointer<const armnnSerializer::QLstmDescriptor *>(
VT_DESCRIPTOR);
8912 return GetPointer<const armnnSerializer::QLstmInputParams *>(VT_INPUTPARAMS);
8914 bool Verify(flatbuffers::Verifier &verifier)
const {
8915 return VerifyTableStart(verifier) &&
8916 VerifyOffset(verifier,
VT_BASE) &&
8917 verifier.VerifyTable(base()) &&
8919 verifier.VerifyTable(descriptor()) &&
8920 VerifyOffset(verifier, VT_INPUTPARAMS) &&
8921 verifier.VerifyTable(inputParams()) &&
8922 verifier.EndTable();
8928 flatbuffers::FlatBufferBuilder &
fbb_;
8930 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
8933 void add_descriptor(flatbuffers::Offset<armnnSerializer::QLstmDescriptor> descriptor) {
8936 void add_inputParams(flatbuffers::Offset<armnnSerializer::QLstmInputParams> inputParams) {
8937 fbb_.AddOffset(QLstmLayer::VT_INPUTPARAMS, inputParams);
8941 start_ = fbb_.StartTable();
8945 const auto end = fbb_.EndTable(start_);
8946 auto o = flatbuffers::Offset<QLstmLayer>(end);
8952 flatbuffers::FlatBufferBuilder &_fbb,
8953 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
8954 flatbuffers::Offset<armnnSerializer::QLstmDescriptor> descriptor = 0,
8955 flatbuffers::Offset<armnnSerializer::QLstmInputParams> inputParams = 0) {
8960 return builder_.
Finish();
8963 struct QuantizedLstmInputParams FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
8965 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9010 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_CELLBIAS);
9015 bool Verify(flatbuffers::Verifier &verifier)
const {
9016 return VerifyTableStart(verifier) &&
9018 verifier.VerifyTable(inputToInputWeights()) &&
9020 verifier.VerifyTable(inputToForgetWeights()) &&
9022 verifier.VerifyTable(inputToCellWeights()) &&
9024 verifier.VerifyTable(inputToOutputWeights()) &&
9026 verifier.VerifyTable(recurrentToInputWeights()) &&
9028 verifier.VerifyTable(recurrentToForgetWeights()) &&
9030 verifier.VerifyTable(recurrentToCellWeights()) &&
9032 verifier.VerifyTable(recurrentToOutputWeights()) &&
9034 verifier.VerifyTable(inputGateBias()) &&
9036 verifier.VerifyTable(forgetGateBias()) &&
9038 verifier.VerifyTable(cellBias()) &&
9040 verifier.VerifyTable(outputGateBias()) &&
9041 verifier.EndTable();
9047 flatbuffers::FlatBufferBuilder &
fbb_;
9079 void add_cellBias(flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias) {
9087 start_ = fbb_.StartTable();
9090 flatbuffers::Offset<QuantizedLstmInputParams>
Finish() {
9091 const auto end = fbb_.EndTable(start_);
9092 auto o = flatbuffers::Offset<QuantizedLstmInputParams>(end);
9098 flatbuffers::FlatBufferBuilder &_fbb,
9099 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToInputWeights = 0,
9100 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToForgetWeights = 0,
9101 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToCellWeights = 0,
9102 flatbuffers::Offset<armnnSerializer::ConstTensor> inputToOutputWeights = 0,
9103 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToInputWeights = 0,
9104 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToForgetWeights = 0,
9105 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToCellWeights = 0,
9106 flatbuffers::Offset<armnnSerializer::ConstTensor> recurrentToOutputWeights = 0,
9107 flatbuffers::Offset<armnnSerializer::ConstTensor> inputGateBias = 0,
9108 flatbuffers::Offset<armnnSerializer::ConstTensor> forgetGateBias = 0,
9109 flatbuffers::Offset<armnnSerializer::ConstTensor> cellBias = 0,
9110 flatbuffers::Offset<armnnSerializer::ConstTensor> outputGateBias = 0) {
9124 return builder_.
Finish();
9127 struct QuantizedLstmLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9129 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9133 const armnnSerializer::LayerBase *
base()
const {
9134 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9136 const armnnSerializer::QuantizedLstmInputParams *
inputParams()
const {
9137 return GetPointer<const armnnSerializer::QuantizedLstmInputParams *>(VT_INPUTPARAMS);
9139 bool Verify(flatbuffers::Verifier &verifier)
const {
9140 return VerifyTableStart(verifier) &&
9141 VerifyOffset(verifier,
VT_BASE) &&
9142 verifier.VerifyTable(base()) &&
9143 VerifyOffset(verifier, VT_INPUTPARAMS) &&
9144 verifier.VerifyTable(inputParams()) &&
9145 verifier.EndTable();
9151 flatbuffers::FlatBufferBuilder &
fbb_;
9153 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9156 void add_inputParams(flatbuffers::Offset<armnnSerializer::QuantizedLstmInputParams> inputParams) {
9157 fbb_.AddOffset(QuantizedLstmLayer::VT_INPUTPARAMS, inputParams);
9161 start_ = fbb_.StartTable();
9164 flatbuffers::Offset<QuantizedLstmLayer>
Finish() {
9165 const auto end = fbb_.EndTable(start_);
9166 auto o = flatbuffers::Offset<QuantizedLstmLayer>(end);
9172 flatbuffers::FlatBufferBuilder &_fbb,
9173 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9174 flatbuffers::Offset<armnnSerializer::QuantizedLstmInputParams> inputParams = 0) {
9178 return builder_.
Finish();
9181 struct DequantizeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9183 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9186 const armnnSerializer::LayerBase *
base()
const {
9187 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9189 bool Verify(flatbuffers::Verifier &verifier)
const {
9190 return VerifyTableStart(verifier) &&
9191 VerifyOffset(verifier,
VT_BASE) &&
9192 verifier.VerifyTable(base()) &&
9193 verifier.EndTable();
9199 flatbuffers::FlatBufferBuilder &
fbb_;
9201 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9206 start_ = fbb_.StartTable();
9209 flatbuffers::Offset<DequantizeLayer>
Finish() {
9210 const auto end = fbb_.EndTable(start_);
9211 auto o = flatbuffers::Offset<DequantizeLayer>(end);
9217 flatbuffers::FlatBufferBuilder &_fbb,
9218 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
9221 return builder_.
Finish();
9224 struct MergeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9226 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9229 const armnnSerializer::LayerBase *
base()
const {
9230 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9232 bool Verify(flatbuffers::Verifier &verifier)
const {
9233 return VerifyTableStart(verifier) &&
9234 VerifyOffset(verifier,
VT_BASE) &&
9235 verifier.VerifyTable(base()) &&
9236 verifier.EndTable();
9242 flatbuffers::FlatBufferBuilder &
fbb_;
9244 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9249 start_ = fbb_.StartTable();
9253 const auto end = fbb_.EndTable(start_);
9254 auto o = flatbuffers::Offset<MergeLayer>(end);
9260 flatbuffers::FlatBufferBuilder &_fbb,
9261 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
9264 return builder_.
Finish();
9267 struct SwitchLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9269 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9272 const armnnSerializer::LayerBase *
base()
const {
9273 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9275 bool Verify(flatbuffers::Verifier &verifier)
const {
9276 return VerifyTableStart(verifier) &&
9277 VerifyOffset(verifier,
VT_BASE) &&
9278 verifier.VerifyTable(base()) &&
9279 verifier.EndTable();
9285 flatbuffers::FlatBufferBuilder &
fbb_;
9287 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9292 start_ = fbb_.StartTable();
9296 const auto end = fbb_.EndTable(start_);
9297 auto o = flatbuffers::Offset<SwitchLayer>(end);
9303 flatbuffers::FlatBufferBuilder &_fbb,
9304 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
9307 return builder_.
Finish();
9310 struct PreluLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9312 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9315 const armnnSerializer::LayerBase *
base()
const {
9316 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9318 bool Verify(flatbuffers::Verifier &verifier)
const {
9319 return VerifyTableStart(verifier) &&
9320 VerifyOffset(verifier,
VT_BASE) &&
9321 verifier.VerifyTable(base()) &&
9322 verifier.EndTable();
9328 flatbuffers::FlatBufferBuilder &
fbb_;
9330 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9335 start_ = fbb_.StartTable();
9339 const auto end = fbb_.EndTable(start_);
9340 auto o = flatbuffers::Offset<PreluLayer>(end);
9346 flatbuffers::FlatBufferBuilder &_fbb,
9347 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
9350 return builder_.
Finish();
9353 struct TransposeConvolution2dLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9355 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9361 const armnnSerializer::LayerBase *
base()
const {
9362 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9364 const armnnSerializer::TransposeConvolution2dDescriptor *
descriptor()
const {
9365 return GetPointer<const armnnSerializer::TransposeConvolution2dDescriptor *>(
VT_DESCRIPTOR);
9367 const armnnSerializer::ConstTensor *
weights()
const {
9368 return GetPointer<const armnnSerializer::ConstTensor *>(
VT_WEIGHTS);
9370 const armnnSerializer::ConstTensor *
biases()
const {
9371 return GetPointer<const armnnSerializer::ConstTensor *>(VT_BIASES);
9373 bool Verify(flatbuffers::Verifier &verifier)
const {
9374 return VerifyTableStart(verifier) &&
9375 VerifyOffset(verifier,
VT_BASE) &&
9376 verifier.VerifyTable(base()) &&
9378 verifier.VerifyTable(descriptor()) &&
9380 verifier.VerifyTable(weights()) &&
9381 VerifyOffset(verifier, VT_BIASES) &&
9382 verifier.VerifyTable(biases()) &&
9383 verifier.EndTable();
9388 typedef TransposeConvolution2dLayer
Table;
9389 flatbuffers::FlatBufferBuilder &
fbb_;
9391 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9394 void add_descriptor(flatbuffers::Offset<armnnSerializer::TransposeConvolution2dDescriptor> descriptor) {
9397 void add_weights(flatbuffers::Offset<armnnSerializer::ConstTensor> weights) {
9400 void add_biases(flatbuffers::Offset<armnnSerializer::ConstTensor> biases) {
9401 fbb_.AddOffset(TransposeConvolution2dLayer::VT_BIASES, biases);
9405 start_ = fbb_.StartTable();
9408 flatbuffers::Offset<TransposeConvolution2dLayer>
Finish() {
9409 const auto end = fbb_.EndTable(start_);
9410 auto o = flatbuffers::Offset<TransposeConvolution2dLayer>(end);
9416 flatbuffers::FlatBufferBuilder &_fbb,
9417 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9418 flatbuffers::Offset<armnnSerializer::TransposeConvolution2dDescriptor> descriptor = 0,
9419 flatbuffers::Offset<armnnSerializer::ConstTensor> weights = 0,
9420 flatbuffers::Offset<armnnSerializer::ConstTensor> biases = 0) {
9426 return builder_.
Finish();
9429 struct TransposeConvolution2dDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9431 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9448 return GetField<uint32_t>(
VT_PADTOP, 0);
9465 bool Verify(flatbuffers::Verifier &verifier)
const {
9466 return VerifyTableStart(verifier) &&
9467 VerifyField<uint32_t>(verifier,
VT_PADLEFT) &&
9469 VerifyField<uint32_t>(verifier,
VT_PADTOP) &&
9471 VerifyField<uint32_t>(verifier,
VT_STRIDEX) &&
9472 VerifyField<uint32_t>(verifier,
VT_STRIDEY) &&
9475 verifier.EndTable();
9480 typedef TransposeConvolution2dDescriptor
Table;
9481 flatbuffers::FlatBufferBuilder &
fbb_;
9509 start_ = fbb_.StartTable();
9512 flatbuffers::Offset<TransposeConvolution2dDescriptor>
Finish() {
9513 const auto end = fbb_.EndTable(start_);
9514 auto o = flatbuffers::Offset<TransposeConvolution2dDescriptor>(end);
9520 flatbuffers::FlatBufferBuilder &_fbb,
9521 uint32_t padLeft = 0,
9522 uint32_t padRight = 0,
9523 uint32_t padTop = 0,
9524 uint32_t padBottom = 0,
9525 uint32_t strideX = 0,
9526 uint32_t strideY = 0,
9527 bool biasEnabled =
false,
9538 return builder_.
Finish();
9541 struct TransposeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9543 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9547 const armnnSerializer::LayerBase *
base()
const {
9548 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9551 return GetPointer<const armnnSerializer::TransposeDescriptor *>(
VT_DESCRIPTOR);
9553 bool Verify(flatbuffers::Verifier &verifier)
const {
9554 return VerifyTableStart(verifier) &&
9555 VerifyOffset(verifier,
VT_BASE) &&
9556 verifier.VerifyTable(base()) &&
9558 verifier.VerifyTable(descriptor()) &&
9559 verifier.EndTable();
9565 flatbuffers::FlatBufferBuilder &
fbb_;
9567 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9570 void add_descriptor(flatbuffers::Offset<armnnSerializer::TransposeDescriptor> descriptor) {
9575 start_ = fbb_.StartTable();
9578 flatbuffers::Offset<TransposeLayer>
Finish() {
9579 const auto end = fbb_.EndTable(start_);
9580 auto o = flatbuffers::Offset<TransposeLayer>(end);
9586 flatbuffers::FlatBufferBuilder &_fbb,
9587 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9588 flatbuffers::Offset<armnnSerializer::TransposeDescriptor> descriptor = 0) {
9592 return builder_.
Finish();
9595 struct TransposeDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9597 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9601 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DIMMAPPINGS);
9603 bool Verify(flatbuffers::Verifier &verifier)
const {
9604 return VerifyTableStart(verifier) &&
9605 VerifyOffset(verifier, VT_DIMMAPPINGS) &&
9606 verifier.VerifyVector(dimMappings()) &&
9607 verifier.EndTable();
9613 flatbuffers::FlatBufferBuilder &
fbb_;
9616 fbb_.AddOffset(TransposeDescriptor::VT_DIMMAPPINGS, dimMappings);
9620 start_ = fbb_.StartTable();
9623 flatbuffers::Offset<TransposeDescriptor>
Finish() {
9624 const auto end = fbb_.EndTable(start_);
9625 auto o = flatbuffers::Offset<TransposeDescriptor>(end);
9631 flatbuffers::FlatBufferBuilder &_fbb,
9635 return builder_.
Finish();
9639 flatbuffers::FlatBufferBuilder &_fbb,
9640 const std::vector<uint32_t> *dimMappings =
nullptr) {
9641 auto dimMappings__ = dimMappings ? _fbb.CreateVector<uint32_t>(*dimMappings) : 0;
9647 struct ResizeLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9649 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9653 const armnnSerializer::LayerBase *
base()
const {
9654 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9657 return GetPointer<const armnnSerializer::ResizeDescriptor *>(
VT_DESCRIPTOR);
9659 bool Verify(flatbuffers::Verifier &verifier)
const {
9660 return VerifyTableStart(verifier) &&
9661 VerifyOffset(verifier,
VT_BASE) &&
9662 verifier.VerifyTable(base()) &&
9664 verifier.VerifyTable(descriptor()) &&
9665 verifier.EndTable();
9671 flatbuffers::FlatBufferBuilder &
fbb_;
9673 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9676 void add_descriptor(flatbuffers::Offset<armnnSerializer::ResizeDescriptor> descriptor) {
9681 start_ = fbb_.StartTable();
9685 const auto end = fbb_.EndTable(start_);
9686 auto o = flatbuffers::Offset<ResizeLayer>(end);
9692 flatbuffers::FlatBufferBuilder &_fbb,
9693 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9694 flatbuffers::Offset<armnnSerializer::ResizeDescriptor> descriptor = 0) {
9698 return builder_.
Finish();
9701 struct ResizeDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9703 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9709 VT_HALFPIXELCENTERS = 14
9727 return GetField<uint8_t>(VT_HALFPIXELCENTERS, 0) != 0;
9729 bool Verify(flatbuffers::Verifier &verifier)
const {
9730 return VerifyTableStart(verifier) &&
9733 VerifyField<int8_t>(verifier,
VT_METHOD) &&
9736 VerifyField<uint8_t>(verifier, VT_HALFPIXELCENTERS) &&
9737 verifier.EndTable();
9743 flatbuffers::FlatBufferBuilder &
fbb_;
9761 fbb_.AddElement<uint8_t>(ResizeDescriptor::VT_HALFPIXELCENTERS,
static_cast<uint8_t
>(halfPixelCenters), 0);
9765 start_ = fbb_.StartTable();
9768 flatbuffers::Offset<ResizeDescriptor>
Finish() {
9769 const auto end = fbb_.EndTable(start_);
9770 auto o = flatbuffers::Offset<ResizeDescriptor>(end);
9776 flatbuffers::FlatBufferBuilder &_fbb,
9777 uint32_t targetHeight = 0,
9778 uint32_t targetWidth = 0,
9781 bool alignCorners =
false,
9782 bool halfPixelCenters =
false) {
9790 return builder_.
Finish();
9793 struct StackLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9795 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9799 const armnnSerializer::LayerBase *
base()
const {
9800 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9803 return GetPointer<const armnnSerializer::StackDescriptor *>(
VT_DESCRIPTOR);
9805 bool Verify(flatbuffers::Verifier &verifier)
const {
9806 return VerifyTableStart(verifier) &&
9807 VerifyOffset(verifier,
VT_BASE) &&
9808 verifier.VerifyTable(base()) &&
9810 verifier.VerifyTable(descriptor()) &&
9811 verifier.EndTable();
9817 flatbuffers::FlatBufferBuilder &
fbb_;
9819 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
9822 void add_descriptor(flatbuffers::Offset<armnnSerializer::StackDescriptor> descriptor) {
9827 start_ = fbb_.StartTable();
9831 const auto end = fbb_.EndTable(start_);
9832 auto o = flatbuffers::Offset<StackLayer>(end);
9838 flatbuffers::FlatBufferBuilder &_fbb,
9839 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
9840 flatbuffers::Offset<armnnSerializer::StackDescriptor> descriptor = 0) {
9844 return builder_.
Finish();
9847 struct StackDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9849 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9855 return GetField<uint32_t>(
VT_AXIS, 0);
9861 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_INPUTSHAPE);
9863 bool Verify(flatbuffers::Verifier &verifier)
const {
9864 return VerifyTableStart(verifier) &&
9865 VerifyField<uint32_t>(verifier,
VT_AXIS) &&
9867 VerifyOffset(verifier, VT_INPUTSHAPE) &&
9868 verifier.VerifyVector(inputShape()) &&
9869 verifier.EndTable();
9875 flatbuffers::FlatBufferBuilder &
fbb_;
9884 fbb_.AddOffset(StackDescriptor::VT_INPUTSHAPE, inputShape);
9888 start_ = fbb_.StartTable();
9891 flatbuffers::Offset<StackDescriptor>
Finish() {
9892 const auto end = fbb_.EndTable(start_);
9893 auto o = flatbuffers::Offset<StackDescriptor>(end);
9899 flatbuffers::FlatBufferBuilder &_fbb,
9901 uint32_t numInputs = 0,
9907 return builder_.
Finish();
9911 flatbuffers::FlatBufferBuilder &_fbb,
9913 uint32_t numInputs = 0,
9914 const std::vector<uint32_t> *inputShape =
nullptr) {
9915 auto inputShape__ = inputShape ? _fbb.CreateVector<uint32_t>(*inputShape) : 0;
9923 struct StandInDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9925 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9933 return GetField<uint32_t>(VT_NUMOUTPUTS, 0);
9935 bool Verify(flatbuffers::Verifier &verifier)
const {
9936 return VerifyTableStart(verifier) &&
9938 VerifyField<uint32_t>(verifier, VT_NUMOUTPUTS) &&
9939 verifier.EndTable();
9945 flatbuffers::FlatBufferBuilder &
fbb_;
9951 fbb_.AddElement<uint32_t>(StandInDescriptor::VT_NUMOUTPUTS, numOutputs, 0);
9955 start_ = fbb_.StartTable();
9958 flatbuffers::Offset<StandInDescriptor>
Finish() {
9959 const auto end = fbb_.EndTable(start_);
9960 auto o = flatbuffers::Offset<StandInDescriptor>(end);
9966 flatbuffers::FlatBufferBuilder &_fbb,
9967 uint32_t numInputs = 0,
9968 uint32_t numOutputs = 0) {
9972 return builder_.
Finish();
9975 struct StandInLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
9977 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9981 const armnnSerializer::LayerBase *
base()
const {
9982 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
9985 return GetPointer<const armnnSerializer::StandInDescriptor *>(
VT_DESCRIPTOR);
9987 bool Verify(flatbuffers::Verifier &verifier)
const {
9988 return VerifyTableStart(verifier) &&
9989 VerifyOffset(verifier,
VT_BASE) &&
9990 verifier.VerifyTable(base()) &&
9992 verifier.VerifyTable(descriptor()) &&
9993 verifier.EndTable();
9999 flatbuffers::FlatBufferBuilder &
fbb_;
10001 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
10004 void add_descriptor(flatbuffers::Offset<armnnSerializer::StandInDescriptor> descriptor) {
10009 start_ = fbb_.StartTable();
10013 const auto end = fbb_.EndTable(start_);
10014 auto o = flatbuffers::Offset<StandInLayer>(end);
10020 flatbuffers::FlatBufferBuilder &_fbb,
10021 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
10022 flatbuffers::Offset<armnnSerializer::StandInDescriptor> descriptor = 0) {
10026 return builder_.
Finish();
10029 struct RankLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
10031 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10034 const armnnSerializer::LayerBase *
base()
const {
10035 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
10037 bool Verify(flatbuffers::Verifier &verifier)
const {
10038 return VerifyTableStart(verifier) &&
10039 VerifyOffset(verifier,
VT_BASE) &&
10040 verifier.VerifyTable(base()) &&
10041 verifier.EndTable();
10049 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
10054 start_ = fbb_.StartTable();
10058 const auto end = fbb_.EndTable(start_);
10059 auto o = flatbuffers::Offset<RankLayer>(end);
10065 flatbuffers::FlatBufferBuilder &_fbb,
10066 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
10069 return builder_.
Finish();
10072 struct ReduceLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
10074 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10078 const armnnSerializer::LayerBase *
base()
const {
10079 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
10082 return GetPointer<const armnnSerializer::ReduceDescriptor *>(
VT_DESCRIPTOR);
10084 bool Verify(flatbuffers::Verifier &verifier)
const {
10085 return VerifyTableStart(verifier) &&
10086 VerifyOffset(verifier,
VT_BASE) &&
10087 verifier.VerifyTable(base()) &&
10089 verifier.VerifyTable(descriptor()) &&
10090 verifier.EndTable();
10098 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
10106 start_ = fbb_.StartTable();
10110 const auto end = fbb_.EndTable(start_);
10111 auto o = flatbuffers::Offset<ReduceLayer>(end);
10117 flatbuffers::FlatBufferBuilder &_fbb,
10118 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
10119 flatbuffers::Offset<armnnSerializer::ReduceDescriptor> descriptor = 0) {
10123 return builder_.
Finish();
10126 struct ReduceDescriptor FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
10128 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10131 VT_REDUCEOPERATION = 8
10136 const flatbuffers::Vector<uint32_t> *
axis()
const {
10137 return GetPointer<const flatbuffers::Vector<uint32_t> *>(
VT_AXIS);
10142 bool Verify(flatbuffers::Verifier &verifier)
const {
10143 return VerifyTableStart(verifier) &&
10145 VerifyOffset(verifier,
VT_AXIS) &&
10146 verifier.VerifyVector(axis()) &&
10147 VerifyField<int8_t>(verifier, VT_REDUCEOPERATION) &&
10148 verifier.EndTable();
10163 fbb_.AddElement<int8_t>(ReduceDescriptor::VT_REDUCEOPERATION,
static_cast<int8_t
>(reduceOperation), 0);
10167 start_ = fbb_.StartTable();
10171 const auto end = fbb_.EndTable(start_);
10172 auto o = flatbuffers::Offset<ReduceDescriptor>(end);
10178 flatbuffers::FlatBufferBuilder &_fbb,
10179 bool keepDims =
false,
10186 return builder_.
Finish();
10190 flatbuffers::FlatBufferBuilder &_fbb,
10191 bool keepDims =
false,
10192 const std::vector<uint32_t> *axis =
nullptr,
10194 auto axis__ = axis ? _fbb.CreateVector<uint32_t>(*axis) : 0;
10204 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10236 return GetField<uint8_t>(VT_TIMEMAJOR, 0) != 0;
10238 bool Verify(flatbuffers::Verifier &verifier)
const {
10239 return VerifyTableStart(verifier) &&
10247 VerifyField<uint8_t>(verifier, VT_TIMEMAJOR) &&
10248 verifier.EndTable();
10278 fbb_.AddElement<uint8_t>(UnidirectionalSequenceLstmDescriptor::VT_TIMEMAJOR,
static_cast<uint8_t
>(timeMajor), 0);
10282 start_ = fbb_.StartTable();
10285 flatbuffers::Offset<UnidirectionalSequenceLstmDescriptor>
Finish() {
10286 const auto end = fbb_.EndTable(start_);
10287 auto o = flatbuffers::Offset<UnidirectionalSequenceLstmDescriptor>(end);
10293 flatbuffers::FlatBufferBuilder &_fbb,
10294 uint32_t activationFunc = 0,
10295 float clippingThresCell = 0.0f,
10296 float clippingThresProj = 0.0f,
10297 bool cifgEnabled =
true,
10298 bool peepholeEnabled =
false,
10299 bool projectionEnabled =
false,
10300 bool layerNormEnabled =
false,
10301 bool timeMajor =
false) {
10311 return builder_.
Finish();
10314 struct UnidirectionalSequenceLstmLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
10316 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10321 const armnnSerializer::LayerBase *
base()
const {
10322 return GetPointer<const armnnSerializer::LayerBase *>(
VT_BASE);
10325 return GetPointer<const armnnSerializer::UnidirectionalSequenceLstmDescriptor *>(
VT_DESCRIPTOR);
10328 return GetPointer<const armnnSerializer::LstmInputParams *>(VT_INPUTPARAMS);
10330 bool Verify(flatbuffers::Verifier &verifier)
const {
10331 return VerifyTableStart(verifier) &&
10332 VerifyOffset(verifier,
VT_BASE) &&
10333 verifier.VerifyTable(base()) &&
10335 verifier.VerifyTable(descriptor()) &&
10336 VerifyOffset(verifier, VT_INPUTPARAMS) &&
10337 verifier.VerifyTable(inputParams()) &&
10338 verifier.EndTable();
10343 typedef UnidirectionalSequenceLstmLayer
Table;
10346 void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
10349 void add_descriptor(flatbuffers::Offset<armnnSerializer::UnidirectionalSequenceLstmDescriptor> descriptor) {
10353 fbb_.AddOffset(UnidirectionalSequenceLstmLayer::VT_INPUTPARAMS, inputParams);
10357 start_ = fbb_.StartTable();
10360 flatbuffers::Offset<UnidirectionalSequenceLstmLayer>
Finish() {
10361 const auto end = fbb_.EndTable(start_);
10362 auto o = flatbuffers::Offset<UnidirectionalSequenceLstmLayer>(end);
10368 flatbuffers::FlatBufferBuilder &_fbb,
10369 flatbuffers::Offset<armnnSerializer::LayerBase> base = 0,
10370 flatbuffers::Offset<armnnSerializer::UnidirectionalSequenceLstmDescriptor> descriptor = 0,
10371 flatbuffers::Offset<armnnSerializer::LstmInputParams> inputParams = 0) {
10376 return builder_.
Finish();
10379 struct AnyLayer FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
10381 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10389 return GetPointer<const void *>(VT_LAYER);
10391 template<
typename T>
const T *layer_as()
const;
10596 bool Verify(flatbuffers::Verifier &verifier)
const {
10597 return VerifyTableStart(verifier) &&
10599 VerifyOffset(verifier, VT_LAYER) &&
10601 verifier.EndTable();
10605 template<>
inline const armnnSerializer::ActivationLayer *AnyLayer::layer_as<armnnSerializer::ActivationLayer>()
const {
10606 return layer_as_ActivationLayer();
10609 template<>
inline const armnnSerializer::AdditionLayer *AnyLayer::layer_as<armnnSerializer::AdditionLayer>()
const {
10610 return layer_as_AdditionLayer();
10613 template<>
inline const armnnSerializer::BatchToSpaceNdLayer *AnyLayer::layer_as<armnnSerializer::BatchToSpaceNdLayer>()
const {
10614 return layer_as_BatchToSpaceNdLayer();
10617 template<>
inline const armnnSerializer::BatchNormalizationLayer *AnyLayer::layer_as<armnnSerializer::BatchNormalizationLayer>()
const {
10618 return layer_as_BatchNormalizationLayer();
10621 template<>
inline const armnnSerializer::ConstantLayer *AnyLayer::layer_as<armnnSerializer::ConstantLayer>()
const {
10622 return layer_as_ConstantLayer();
10625 template<>
inline const armnnSerializer::Convolution2dLayer *AnyLayer::layer_as<armnnSerializer::Convolution2dLayer>()
const {
10626 return layer_as_Convolution2dLayer();
10629 template<>
inline const armnnSerializer::DepthwiseConvolution2dLayer *AnyLayer::layer_as<armnnSerializer::DepthwiseConvolution2dLayer>()
const {
10630 return layer_as_DepthwiseConvolution2dLayer();
10633 template<>
inline const armnnSerializer::FullyConnectedLayer *AnyLayer::layer_as<armnnSerializer::FullyConnectedLayer>()
const {
10634 return layer_as_FullyConnectedLayer();
10637 template<>
inline const armnnSerializer::InputLayer *AnyLayer::layer_as<armnnSerializer::InputLayer>()
const {
10638 return layer_as_InputLayer();
10641 template<>
inline const armnnSerializer::MultiplicationLayer *AnyLayer::layer_as<armnnSerializer::MultiplicationLayer>()
const {
10642 return layer_as_MultiplicationLayer();
10645 template<>
inline const armnnSerializer::OutputLayer *AnyLayer::layer_as<armnnSerializer::OutputLayer>()
const {
10646 return layer_as_OutputLayer();
10649 template<>
inline const armnnSerializer::PermuteLayer *AnyLayer::layer_as<armnnSerializer::PermuteLayer>()
const {
10650 return layer_as_PermuteLayer();
10653 template<>
inline const armnnSerializer::Pooling2dLayer *AnyLayer::layer_as<armnnSerializer::Pooling2dLayer>()
const {
10654 return layer_as_Pooling2dLayer();
10657 template<>
inline const armnnSerializer::ReshapeLayer *AnyLayer::layer_as<armnnSerializer::ReshapeLayer>()
const {
10658 return layer_as_ReshapeLayer();
10661 template<>
inline const armnnSerializer::SoftmaxLayer *AnyLayer::layer_as<armnnSerializer::SoftmaxLayer>()
const {
10662 return layer_as_SoftmaxLayer();
10665 template<>
inline const armnnSerializer::SpaceToBatchNdLayer *AnyLayer::layer_as<armnnSerializer::SpaceToBatchNdLayer>()
const {
10666 return layer_as_SpaceToBatchNdLayer();
10669 template<>
inline const armnnSerializer::DivisionLayer *AnyLayer::layer_as<armnnSerializer::DivisionLayer>()
const {
10670 return layer_as_DivisionLayer();
10673 template<>
inline const armnnSerializer::MinimumLayer *AnyLayer::layer_as<armnnSerializer::MinimumLayer>()
const {
10674 return layer_as_MinimumLayer();
10677 template<>
inline const armnnSerializer::EqualLayer *AnyLayer::layer_as<armnnSerializer::EqualLayer>()
const {
10678 return layer_as_EqualLayer();
10681 template<>
inline const armnnSerializer::MaximumLayer *AnyLayer::layer_as<armnnSerializer::MaximumLayer>()
const {
10682 return layer_as_MaximumLayer();
10685 template<>
inline const armnnSerializer::NormalizationLayer *AnyLayer::layer_as<armnnSerializer::NormalizationLayer>()
const {
10686 return layer_as_NormalizationLayer();
10689 template<>
inline const armnnSerializer::PadLayer *AnyLayer::layer_as<armnnSerializer::PadLayer>()
const {
10690 return layer_as_PadLayer();
10693 template<>
inline const armnnSerializer::RsqrtLayer *AnyLayer::layer_as<armnnSerializer::RsqrtLayer>()
const {
10694 return layer_as_RsqrtLayer();
10697 template<>
inline const armnnSerializer::FloorLayer *AnyLayer::layer_as<armnnSerializer::FloorLayer>()
const {
10698 return layer_as_FloorLayer();
10701 template<>
inline const armnnSerializer::GreaterLayer *AnyLayer::layer_as<armnnSerializer::GreaterLayer>()
const {
10702 return layer_as_GreaterLayer();
10705 template<>
inline const armnnSerializer::ResizeBilinearLayer *AnyLayer::layer_as<armnnSerializer::ResizeBilinearLayer>()
const {
10706 return layer_as_ResizeBilinearLayer();
10709 template<>
inline const armnnSerializer::SubtractionLayer *AnyLayer::layer_as<armnnSerializer::SubtractionLayer>()
const {
10710 return layer_as_SubtractionLayer();
10713 template<>
inline const armnnSerializer::StridedSliceLayer *AnyLayer::layer_as<armnnSerializer::StridedSliceLayer>()
const {
10714 return layer_as_StridedSliceLayer();
10717 template<>
inline const armnnSerializer::GatherLayer *AnyLayer::layer_as<armnnSerializer::GatherLayer>()
const {
10718 return layer_as_GatherLayer();
10721 template<>
inline const armnnSerializer::MeanLayer *AnyLayer::layer_as<armnnSerializer::MeanLayer>()
const {
10722 return layer_as_MeanLayer();
10726 return layer_as_MergerLayer();
10729 template<>
inline const armnnSerializer::L2NormalizationLayer *AnyLayer::layer_as<armnnSerializer::L2NormalizationLayer>()
const {
10730 return layer_as_L2NormalizationLayer();
10733 template<>
inline const armnnSerializer::SplitterLayer *AnyLayer::layer_as<armnnSerializer::SplitterLayer>()
const {
10734 return layer_as_SplitterLayer();
10737 template<>
inline const armnnSerializer::DetectionPostProcessLayer *AnyLayer::layer_as<armnnSerializer::DetectionPostProcessLayer>()
const {
10738 return layer_as_DetectionPostProcessLayer();
10741 template<>
inline const armnnSerializer::LstmLayer *AnyLayer::layer_as<armnnSerializer::LstmLayer>()
const {
10742 return layer_as_LstmLayer();
10745 template<>
inline const armnnSerializer::QuantizedLstmLayer *AnyLayer::layer_as<armnnSerializer::QuantizedLstmLayer>()
const {
10746 return layer_as_QuantizedLstmLayer();
10749 template<>
inline const armnnSerializer::QuantizeLayer *AnyLayer::layer_as<armnnSerializer::QuantizeLayer>()
const {
10750 return layer_as_QuantizeLayer();
10753 template<>
inline const armnnSerializer::DequantizeLayer *AnyLayer::layer_as<armnnSerializer::DequantizeLayer>()
const {
10754 return layer_as_DequantizeLayer();
10757 template<>
inline const armnnSerializer::MergeLayer *AnyLayer::layer_as<armnnSerializer::MergeLayer>()
const {
10758 return layer_as_MergeLayer();
10761 template<>
inline const armnnSerializer::SwitchLayer *AnyLayer::layer_as<armnnSerializer::SwitchLayer>()
const {
10762 return layer_as_SwitchLayer();
10765 template<>
inline const armnnSerializer::ConcatLayer *AnyLayer::layer_as<armnnSerializer::ConcatLayer>()
const {
10766 return layer_as_ConcatLayer();
10769 template<>
inline const armnnSerializer::SpaceToDepthLayer *AnyLayer::layer_as<armnnSerializer::SpaceToDepthLayer>()
const {
10770 return layer_as_SpaceToDepthLayer();
10773 template<>
inline const armnnSerializer::PreluLayer *AnyLayer::layer_as<armnnSerializer::PreluLayer>()
const {
10774 return layer_as_PreluLayer();
10777 template<>
inline const armnnSerializer::TransposeConvolution2dLayer *AnyLayer::layer_as<armnnSerializer::TransposeConvolution2dLayer>()
const {
10778 return layer_as_TransposeConvolution2dLayer();
10781 template<>
inline const armnnSerializer::ResizeLayer *AnyLayer::layer_as<armnnSerializer::ResizeLayer>()
const {
10782 return layer_as_ResizeLayer();
10785 template<>
inline const armnnSerializer::StackLayer *AnyLayer::layer_as<armnnSerializer::StackLayer>()
const {
10786 return layer_as_StackLayer();
10789 template<>
inline const armnnSerializer::AbsLayer *AnyLayer::layer_as<armnnSerializer::AbsLayer>()
const {
10790 return layer_as_AbsLayer();
10793 template<>
inline const armnnSerializer::ArgMinMaxLayer *AnyLayer::layer_as<armnnSerializer::ArgMinMaxLayer>()
const {
10794 return layer_as_ArgMinMaxLayer();
10797 template<>
inline const armnnSerializer::SliceLayer *AnyLayer::layer_as<armnnSerializer::SliceLayer>()
const {
10798 return layer_as_SliceLayer();
10801 template<>
inline const armnnSerializer::DepthToSpaceLayer *AnyLayer::layer_as<armnnSerializer::DepthToSpaceLayer>()
const {
10802 return layer_as_DepthToSpaceLayer();
10805 template<>
inline const armnnSerializer::InstanceNormalizationLayer *AnyLayer::layer_as<armnnSerializer::InstanceNormalizationLayer>()
const {
10806 return layer_as_InstanceNormalizationLayer();
10809 template<>
inline const armnnSerializer::LogSoftmaxLayer *AnyLayer::layer_as<armnnSerializer::LogSoftmaxLayer>()
const {
10810 return layer_as_LogSoftmaxLayer();
10813 template<>
inline const armnnSerializer::ComparisonLayer *AnyLayer::layer_as<armnnSerializer::ComparisonLayer>()
const {
10814 return layer_as_ComparisonLayer();
10817 template<>
inline const armnnSerializer::StandInLayer *AnyLayer::layer_as<armnnSerializer::StandInLayer>()
const {
10818 return layer_as_StandInLayer();
10821 template<>
inline const armnnSerializer::ElementwiseUnaryLayer *AnyLayer::layer_as<armnnSerializer::ElementwiseUnaryLayer>()
const {
10822 return layer_as_ElementwiseUnaryLayer();
10825 template<>
inline const armnnSerializer::TransposeLayer *AnyLayer::layer_as<armnnSerializer::TransposeLayer>()
const {
10826 return layer_as_TransposeLayer();
10829 template<>
inline const armnnSerializer::QLstmLayer *AnyLayer::layer_as<armnnSerializer::QLstmLayer>()
const {
10830 return layer_as_QLstmLayer();
10833 template<>
inline const armnnSerializer::FillLayer *AnyLayer::layer_as<armnnSerializer::FillLayer>()
const {
10834 return layer_as_FillLayer();
10837 template<>
inline const armnnSerializer::RankLayer *AnyLayer::layer_as<armnnSerializer::RankLayer>()
const {
10838 return layer_as_RankLayer();
10841 template<>
inline const armnnSerializer::LogicalBinaryLayer *AnyLayer::layer_as<armnnSerializer::LogicalBinaryLayer>()
const {
10842 return layer_as_LogicalBinaryLayer();
10845 template<>
inline const armnnSerializer::ReduceLayer *AnyLayer::layer_as<armnnSerializer::ReduceLayer>()
const {
10846 return layer_as_ReduceLayer();
10849 template<>
inline const armnnSerializer::CastLayer *AnyLayer::layer_as<armnnSerializer::CastLayer>()
const {
10850 return layer_as_CastLayer();
10853 template<>
inline const armnnSerializer::ShapeLayer *AnyLayer::layer_as<armnnSerializer::ShapeLayer>()
const {
10854 return layer_as_ShapeLayer();
10857 template<>
inline const armnnSerializer::UnidirectionalSequenceLstmLayer *AnyLayer::layer_as<armnnSerializer::UnidirectionalSequenceLstmLayer>()
const {
10858 return layer_as_UnidirectionalSequenceLstmLayer();
10861 template<>
inline const armnnSerializer::ChannelShuffleLayer *AnyLayer::layer_as<armnnSerializer::ChannelShuffleLayer>()
const {
10862 return layer_as_ChannelShuffleLayer();
10865 template<>
inline const armnnSerializer::Convolution3dLayer *AnyLayer::layer_as<armnnSerializer::Convolution3dLayer>()
const {
10866 return layer_as_Convolution3dLayer();
10869 template<>
inline const armnnSerializer::Pooling3dLayer *AnyLayer::layer_as<armnnSerializer::Pooling3dLayer>()
const {
10870 return layer_as_Pooling3dLayer();
10873 template<>
inline const armnnSerializer::GatherNdLayer *AnyLayer::layer_as<armnnSerializer::GatherNdLayer>()
const {
10874 return layer_as_GatherNdLayer();
10885 fbb_.AddOffset(AnyLayer::VT_LAYER, layer);
10889 start_ = fbb_.StartTable();
10893 const auto end = fbb_.EndTable(start_);
10894 auto o = flatbuffers::Offset<AnyLayer>(end);
10900 flatbuffers::FlatBufferBuilder &_fbb,
10902 flatbuffers::Offset<void> layer = 0) {
10906 return builder_.
Finish();
10909 struct FeatureCompatibilityVersions FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
10911 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10914 VT_CONSTANTTENSORSASINPUTS = 8
10923 return GetField<uint32_t>(VT_CONSTANTTENSORSASINPUTS, 0);
10925 bool Verify(flatbuffers::Verifier &verifier)
const {
10926 return VerifyTableStart(verifier) &&
10929 VerifyField<uint32_t>(verifier, VT_CONSTANTTENSORSASINPUTS) &&
10930 verifier.EndTable();
10945 fbb_.AddElement<uint32_t>(FeatureCompatibilityVersions::VT_CONSTANTTENSORSASINPUTS, constantTensorsAsInputs, 0);
10949 start_ = fbb_.StartTable();
10952 flatbuffers::Offset<FeatureCompatibilityVersions>
Finish() {
10953 const auto end = fbb_.EndTable(start_);
10954 auto o = flatbuffers::Offset<FeatureCompatibilityVersions>(end);
10960 flatbuffers::FlatBufferBuilder &_fbb,
10961 uint32_t bindingIdsScheme = 0,
10962 uint32_t weightsLayoutScheme = 0,
10963 uint32_t constantTensorsAsInputs = 0) {
10968 return builder_.
Finish();
10971 struct SerializedGraph FLATBUFFERS_FINAL_CLASS :
private flatbuffers::Table {
10973 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10977 VT_FEATUREVERSIONS = 10
10979 const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::AnyLayer>> *
layers()
const {
10980 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::AnyLayer>> *>(
VT_LAYERS);
10983 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_INPUTIDS);
10986 return GetPointer<const flatbuffers::Vector<int32_t> *>(
VT_OUTPUTIDS);
10989 return GetPointer<const armnnSerializer::FeatureCompatibilityVersions *>(VT_FEATUREVERSIONS);
10991 bool Verify(flatbuffers::Verifier &verifier)
const {
10992 return VerifyTableStart(verifier) &&
10994 verifier.VerifyVector(layers()) &&
10995 verifier.VerifyVectorOfTables(layers()) &&
10997 verifier.VerifyVector(inputIds()) &&
10999 verifier.VerifyVector(outputIds()) &&
11000 VerifyOffset(verifier, VT_FEATUREVERSIONS) &&
11001 verifier.VerifyTable(featureVersions()) &&
11002 verifier.EndTable();
11020 fbb_.AddOffset(SerializedGraph::VT_FEATUREVERSIONS, featureVersions);
11024 start_ = fbb_.StartTable();
11028 const auto end = fbb_.EndTable(start_);
11029 auto o = flatbuffers::Offset<SerializedGraph>(end);
11035 flatbuffers::FlatBufferBuilder &_fbb,
11036 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<armnnSerializer::AnyLayer>>> layers = 0,
11039 flatbuffers::Offset<armnnSerializer::FeatureCompatibilityVersions> featureVersions = 0) {
11045 return builder_.
Finish();
11049 flatbuffers::FlatBufferBuilder &_fbb,
11050 const std::vector<flatbuffers::Offset<armnnSerializer::AnyLayer>> *layers =
nullptr,
11051 const std::vector<int32_t> *inputIds =
nullptr,
11052 const std::vector<int32_t> *outputIds =
nullptr,
11053 flatbuffers::Offset<armnnSerializer::FeatureCompatibilityVersions> featureVersions = 0) {
11054 auto layers__ = layers ? _fbb.CreateVector<flatbuffers::Offset<armnnSerializer::AnyLayer>>(*layers) : 0;
11055 auto inputIds__ = inputIds ? _fbb.CreateVector<int32_t>(*inputIds) : 0;
11056 auto outputIds__ = outputIds ? _fbb.CreateVector<int32_t>(*outputIds) : 0;
11071 auto ptr =
reinterpret_cast<const armnnSerializer::ByteData *
>(obj);
11072 return verifier.VerifyTable(ptr);
11075 auto ptr =
reinterpret_cast<const armnnSerializer::ShortData *
>(obj);
11076 return verifier.VerifyTable(ptr);
11079 auto ptr =
reinterpret_cast<const armnnSerializer::IntData *
>(obj);
11080 return verifier.VerifyTable(ptr);
11083 auto ptr =
reinterpret_cast<const armnnSerializer::LongData *
>(obj);
11084 return verifier.VerifyTable(ptr);
11086 default:
return true;
11090 inline bool VerifyConstTensorDataVector(flatbuffers::Verifier &verifier,
const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
const flatbuffers::Vector<uint8_t> *types) {
11091 if (!values || !types)
return !values && !types;
11092 if (values->size() != types->size())
return false;
11093 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
11108 auto ptr =
reinterpret_cast<const armnnSerializer::ActivationLayer *
>(obj);
11109 return verifier.VerifyTable(ptr);
11112 auto ptr =
reinterpret_cast<const armnnSerializer::AdditionLayer *
>(obj);
11113 return verifier.VerifyTable(ptr);
11116 auto ptr =
reinterpret_cast<const armnnSerializer::BatchToSpaceNdLayer *
>(obj);
11117 return verifier.VerifyTable(ptr);
11120 auto ptr =
reinterpret_cast<const armnnSerializer::BatchNormalizationLayer *
>(obj);
11121 return verifier.VerifyTable(ptr);
11124 auto ptr =
reinterpret_cast<const armnnSerializer::ConstantLayer *
>(obj);
11125 return verifier.VerifyTable(ptr);
11128 auto ptr =
reinterpret_cast<const armnnSerializer::Convolution2dLayer *
>(obj);
11129 return verifier.VerifyTable(ptr);
11132 auto ptr =
reinterpret_cast<const armnnSerializer::DepthwiseConvolution2dLayer *
>(obj);
11133 return verifier.VerifyTable(ptr);
11136 auto ptr =
reinterpret_cast<const armnnSerializer::FullyConnectedLayer *
>(obj);
11137 return verifier.VerifyTable(ptr);
11140 auto ptr =
reinterpret_cast<const armnnSerializer::InputLayer *
>(obj);
11141 return verifier.VerifyTable(ptr);
11144 auto ptr =
reinterpret_cast<const armnnSerializer::MultiplicationLayer *
>(obj);
11145 return verifier.VerifyTable(ptr);
11148 auto ptr =
reinterpret_cast<const armnnSerializer::OutputLayer *
>(obj);
11149 return verifier.VerifyTable(ptr);
11152 auto ptr =
reinterpret_cast<const armnnSerializer::PermuteLayer *
>(obj);
11153 return verifier.VerifyTable(ptr);
11156 auto ptr =
reinterpret_cast<const armnnSerializer::Pooling2dLayer *
>(obj);
11157 return verifier.VerifyTable(ptr);
11160 auto ptr =
reinterpret_cast<const armnnSerializer::ReshapeLayer *
>(obj);
11161 return verifier.VerifyTable(ptr);
11164 auto ptr =
reinterpret_cast<const armnnSerializer::SoftmaxLayer *
>(obj);
11165 return verifier.VerifyTable(ptr);
11168 auto ptr =
reinterpret_cast<const armnnSerializer::SpaceToBatchNdLayer *
>(obj);
11169 return verifier.VerifyTable(ptr);
11172 auto ptr =
reinterpret_cast<const armnnSerializer::DivisionLayer *
>(obj);
11173 return verifier.VerifyTable(ptr);
11176 auto ptr =
reinterpret_cast<const armnnSerializer::MinimumLayer *
>(obj);
11177 return verifier.VerifyTable(ptr);
11180 auto ptr =
reinterpret_cast<const armnnSerializer::EqualLayer *
>(obj);
11181 return verifier.VerifyTable(ptr);
11184 auto ptr =
reinterpret_cast<const armnnSerializer::MaximumLayer *
>(obj);
11185 return verifier.VerifyTable(ptr);
11188 auto ptr =
reinterpret_cast<const armnnSerializer::NormalizationLayer *
>(obj);
11189 return verifier.VerifyTable(ptr);
11192 auto ptr =
reinterpret_cast<const armnnSerializer::PadLayer *
>(obj);
11193 return verifier.VerifyTable(ptr);
11196 auto ptr =
reinterpret_cast<const armnnSerializer::RsqrtLayer *
>(obj);
11197 return verifier.VerifyTable(ptr);
11200 auto ptr =
reinterpret_cast<const armnnSerializer::FloorLayer *
>(obj);
11201 return verifier.VerifyTable(ptr);
11204 auto ptr =
reinterpret_cast<const armnnSerializer::GreaterLayer *
>(obj);
11205 return verifier.VerifyTable(ptr);
11208 auto ptr =
reinterpret_cast<const armnnSerializer::ResizeBilinearLayer *
>(obj);
11209 return verifier.VerifyTable(ptr);
11212 auto ptr =
reinterpret_cast<const armnnSerializer::SubtractionLayer *
>(obj);
11213 return verifier.VerifyTable(ptr);
11216 auto ptr =
reinterpret_cast<const armnnSerializer::StridedSliceLayer *
>(obj);
11217 return verifier.VerifyTable(ptr);
11220 auto ptr =
reinterpret_cast<const armnnSerializer::GatherLayer *
>(obj);
11221 return verifier.VerifyTable(ptr);
11224 auto ptr =
reinterpret_cast<const armnnSerializer::MeanLayer *
>(obj);
11225 return verifier.VerifyTable(ptr);
11229 return verifier.VerifyTable(ptr);
11232 auto ptr =
reinterpret_cast<const armnnSerializer::L2NormalizationLayer *
>(obj);
11233 return verifier.VerifyTable(ptr);
11236 auto ptr =
reinterpret_cast<const armnnSerializer::SplitterLayer *
>(obj);
11237 return verifier.VerifyTable(ptr);
11240 auto ptr =
reinterpret_cast<const armnnSerializer::DetectionPostProcessLayer *
>(obj);
11241 return verifier.VerifyTable(ptr);
11244 auto ptr =
reinterpret_cast<const armnnSerializer::LstmLayer *
>(obj);
11245 return verifier.VerifyTable(ptr);
11248 auto ptr =
reinterpret_cast<const armnnSerializer::QuantizedLstmLayer *
>(obj);
11249 return verifier.VerifyTable(ptr);
11252 auto ptr =
reinterpret_cast<const armnnSerializer::QuantizeLayer *
>(obj);
11253 return verifier.VerifyTable(ptr);
11256 auto ptr =
reinterpret_cast<const armnnSerializer::DequantizeLayer *
>(obj);
11257 return verifier.VerifyTable(ptr);
11260 auto ptr =
reinterpret_cast<const armnnSerializer::MergeLayer *
>(obj);
11261 return verifier.VerifyTable(ptr);
11264 auto ptr =
reinterpret_cast<const armnnSerializer::SwitchLayer *
>(obj);
11265 return verifier.VerifyTable(ptr);
11268 auto ptr =
reinterpret_cast<const armnnSerializer::ConcatLayer *
>(obj);
11269 return verifier.VerifyTable(ptr);
11272 auto ptr =
reinterpret_cast<const armnnSerializer::SpaceToDepthLayer *
>(obj);
11273 return verifier.VerifyTable(ptr);
11276 auto ptr =
reinterpret_cast<const armnnSerializer::PreluLayer *
>(obj);
11277 return verifier.VerifyTable(ptr);
11280 auto ptr =
reinterpret_cast<const armnnSerializer::TransposeConvolution2dLayer *
>(obj);
11281 return verifier.VerifyTable(ptr);
11284 auto ptr =
reinterpret_cast<const armnnSerializer::ResizeLayer *
>(obj);
11285 return verifier.VerifyTable(ptr);
11288 auto ptr =
reinterpret_cast<const armnnSerializer::StackLayer *
>(obj);
11289 return verifier.VerifyTable(ptr);
11292 auto ptr =
reinterpret_cast<const armnnSerializer::AbsLayer *
>(obj);
11293 return verifier.VerifyTable(ptr);
11296 auto ptr =
reinterpret_cast<const armnnSerializer::ArgMinMaxLayer *
>(obj);
11297 return verifier.VerifyTable(ptr);
11300 auto ptr =
reinterpret_cast<const armnnSerializer::SliceLayer *
>(obj);
11301 return verifier.VerifyTable(ptr);
11304 auto ptr =
reinterpret_cast<const armnnSerializer::DepthToSpaceLayer *
>(obj);
11305 return verifier.VerifyTable(ptr);
11308 auto ptr =
reinterpret_cast<const armnnSerializer::InstanceNormalizationLayer *
>(obj);
11309 return verifier.VerifyTable(ptr);
11312 auto ptr =
reinterpret_cast<const armnnSerializer::LogSoftmaxLayer *
>(obj);
11313 return verifier.VerifyTable(ptr);
11316 auto ptr =
reinterpret_cast<const armnnSerializer::ComparisonLayer *
>(obj);
11317 return verifier.VerifyTable(ptr);
11320 auto ptr =
reinterpret_cast<const armnnSerializer::StandInLayer *
>(obj);
11321 return verifier.VerifyTable(ptr);
11324 auto ptr =
reinterpret_cast<const armnnSerializer::ElementwiseUnaryLayer *
>(obj);
11325 return verifier.VerifyTable(ptr);
11328 auto ptr =
reinterpret_cast<const armnnSerializer::TransposeLayer *
>(obj);
11329 return verifier.VerifyTable(ptr);
11332 auto ptr =
reinterpret_cast<const armnnSerializer::QLstmLayer *
>(obj);
11333 return verifier.VerifyTable(ptr);
11336 auto ptr =
reinterpret_cast<const armnnSerializer::FillLayer *
>(obj);
11337 return verifier.VerifyTable(ptr);
11340 auto ptr =
reinterpret_cast<const armnnSerializer::RankLayer *
>(obj);
11341 return verifier.VerifyTable(ptr);
11344 auto ptr =
reinterpret_cast<const armnnSerializer::LogicalBinaryLayer *
>(obj);
11345 return verifier.VerifyTable(ptr);
11348 auto ptr =
reinterpret_cast<const armnnSerializer::ReduceLayer *
>(obj);
11349 return verifier.VerifyTable(ptr);
11352 auto ptr =
reinterpret_cast<const armnnSerializer::CastLayer *
>(obj);
11353 return verifier.VerifyTable(ptr);
11356 auto ptr =
reinterpret_cast<const armnnSerializer::ShapeLayer *
>(obj);
11357 return verifier.VerifyTable(ptr);
11360 auto ptr =
reinterpret_cast<const armnnSerializer::UnidirectionalSequenceLstmLayer *
>(obj);
11361 return verifier.VerifyTable(ptr);
11364 auto ptr =
reinterpret_cast<const armnnSerializer::ChannelShuffleLayer *
>(obj);
11365 return verifier.VerifyTable(ptr);
11368 auto ptr =
reinterpret_cast<const armnnSerializer::Convolution3dLayer *
>(obj);
11369 return verifier.VerifyTable(ptr);
11372 auto ptr =
reinterpret_cast<const armnnSerializer::Pooling3dLayer *
>(obj);
11373 return verifier.VerifyTable(ptr);
11376 auto ptr =
reinterpret_cast<const armnnSerializer::GatherNdLayer *
>(obj);
11377 return verifier.VerifyTable(ptr);
11379 default:
return true;
11383 inline bool VerifyLayerVector(flatbuffers::Verifier &verifier,
const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
const flatbuffers::Vector<uint8_t> *types) {
11384 if (!values || !types)
return !values && !types;
11385 if (values->size() != types->size())
return false;
11386 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
11388 verifier, values->Get(i), types->GetEnum<
Layer>(i))) {
11396 return flatbuffers::GetRoot<armnnSerializer::SerializedGraph>(buf);
11400 return flatbuffers::GetSizePrefixedRoot<armnnSerializer::SerializedGraph>(buf);
11408 return flatbuffers::BufferHasIdentifier(
11413 flatbuffers::Verifier &verifier) {
11418 flatbuffers::Verifier &verifier) {
11427 flatbuffers::FlatBufferBuilder &fbb,
11428 flatbuffers::Offset<armnnSerializer::SerializedGraph> root) {
11433 flatbuffers::FlatBufferBuilder &fbb,
11434 flatbuffers::Offset<armnnSerializer::SerializedGraph> root) {
11440 #endif // FLATBUFFERS_GENERATED_ARMNNSCHEMA_ARMNNSERIALIZER_H_ flatbuffers::uoffset_t start_
flatbuffers::Offset< LayerBase > CreateLayerBaseDirect(flatbuffers::FlatBufferBuilder &_fbb, uint32_t index=0, const char *layerName=nullptr, armnnSerializer::LayerType layerType=armnnSerializer::LayerType_Addition, const std::vector< flatbuffers::Offset< armnnSerializer::InputSlot >> *inputSlots=nullptr, const std::vector< flatbuffers::Offset< armnnSerializer::OutputSlot >> *outputSlots=nullptr)
void add_endMask(int32_t endMask)
const armnnSerializer::ConstTensor * weights() const
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
void add_clippingThresCell(float clippingThresCell)
flatbuffers::Offset< MeanLayer > Finish()
flatbuffers::Offset< CastLayer > Finish()
flatbuffers::Offset< TensorInfo > Finish()
const armnnSerializer::RankLayer * layer_as_RankLayer() const
LogSoftmaxDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_poolType(armnnSerializer::PoolingAlgorithm poolType)
flatbuffers::Offset< DepthToSpaceDescriptor > Finish()
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
MultiplicationLayerBuilder Builder
flatbuffers::uoffset_t start_
void add_descriptor(flatbuffers::Offset< armnnSerializer::NormalizationDescriptor > descriptor)
uint32_t padFront() const
flatbuffers::Offset< DepthToSpaceLayer > Finish()
ChannelShuffleDescriptor Table
float projectionClip() const
void add_normSize(uint32_t normSize)
const armnnSerializer::ConstTensor * inputToOutputWeights() const
ConstantLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_anchors(flatbuffers::Offset< armnnSerializer::ConstTensor > anchors)
uint32_t numClasses() const
const armnnSerializer::AdditionLayer * layer_as_AdditionLayer() const
ReduceDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< SplitterLayer > Finish()
flatbuffers::Offset< Convolution3dDescriptor > CreateConvolution3dDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t padLeft=0, uint32_t padRight=0, uint32_t padTop=0, uint32_t padBottom=0, uint32_t padFront=0, uint32_t padBack=0, uint32_t strideX=0, uint32_t strideY=0, uint32_t strideZ=0, uint32_t dilationX=1, uint32_t dilationY=1, uint32_t dilationZ=1, bool biasEnabled=false, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NDHWC)
flatbuffers::Offset< LongData > CreateLongData(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< int64_t >> data=0)
void add_scaleW(float scaleW)
uint32_t targetHeight() const
flatbuffers::uoffset_t start_
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
ElementwiseUnaryLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_ellipsisMask(int32_t ellipsisMask)
const armnnSerializer::UnidirectionalSequenceLstmDescriptor * descriptor() const
flatbuffers::FlatBufferBuilder & fbb_
MinimumLayerBuilder Builder
flatbuffers::Offset< LongData > Finish()
void add_strideX(uint32_t strideX)
flatbuffers::uoffset_t start_
Pooling3dLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< ElementwiseUnaryDescriptor > Finish()
FullyConnectedDescriptor Table
const armnnSerializer::MaximumLayer * layer_as_MaximumLayer() const
ElementwiseUnaryDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
TransposeLayerBuilder Builder
void add_descriptor(flatbuffers::Offset< armnnSerializer::ResizeBilinearDescriptor > descriptor)
ViewsDescriptorBuilder Builder
QuantizedLstmLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const Layer(& EnumValuesLayer())[69]
flatbuffers::Offset< ReshapeDescriptor > CreateReshapeDescriptor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> targetShape=0)
Convolution3dLayerBuilder Builder
const armnnSerializer::SliceLayer * layer_as_SliceLayer() const
flatbuffers::FlatBufferBuilder & fbb_
SubtractionLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
RsqrtLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< ReduceLayer > CreateReduceLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ReduceDescriptor > descriptor=0)
void add_descriptor(flatbuffers::Offset< armnnSerializer::SpaceToBatchNdDescriptor > descriptor)
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
int32_t beginMask() const
const armnnSerializer::ConcatLayer * layer_as_ConcatLayer() const
static const ConstTensorData enum_value
flatbuffers::uoffset_t start_
void add_info(flatbuffers::Offset< armnnSerializer::TensorInfo > info)
flatbuffers::Offset< SerializedGraph > CreateSerializedGraphDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< flatbuffers::Offset< armnnSerializer::AnyLayer >> *layers=nullptr, const std::vector< int32_t > *inputIds=nullptr, const std::vector< int32_t > *outputIds=nullptr, flatbuffers::Offset< armnnSerializer::FeatureCompatibilityVersions > featureVersions=0)
ConcatLayerBuilder Builder
const char * EnumNameUnaryOperation(UnaryOperation e)
flatbuffers::Offset< PermuteLayer > Finish()
const armnnSerializer::ConstTensor * inputGateBias() const
const armnnSerializer::NormalizationLayer * layer_as_NormalizationLayer() const
void add_layerNormEnabled(bool layerNormEnabled)
BatchToSpaceNdLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::FillDescriptor * descriptor() const
void add_isConstant(bool isConstant)
flatbuffers::FlatBufferBuilder & fbb_
void add_maxClassesPerDetection(uint32_t maxClassesPerDetection)
void add_dilationY(uint32_t dilationY)
const armnnSerializer::PermuteLayer * layer_as_PermuteLayer() const
void add_activationFunc(uint32_t activationFunc)
flatbuffers::Offset< OutputSlot > CreateOutputSlot(flatbuffers::FlatBufferBuilder &_fbb, uint32_t index=0, flatbuffers::Offset< armnnSerializer::TensorInfo > tensorInfo=0)
flatbuffers::Offset< QLstmDescriptor > Finish()
armnnSerializer::NormalizationAlgorithmMethod normMethodType() const
flatbuffers::Offset< DepthwiseConvolution2dDescriptor > CreateDepthwiseConvolution2dDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t padLeft=0, uint32_t padRight=0, uint32_t padTop=0, uint32_t padBottom=0, uint32_t strideX=0, uint32_t strideY=0, uint32_t dilationX=1, uint32_t dilationY=1, bool biasEnabled=false, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NCHW)
void add_data_type(armnnSerializer::ConstTensorData data_type)
uint32_t padBottom() const
MergerLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
const armnnSerializer::QLstmDescriptor * descriptor() const
SliceDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
MultiplicationLayer Table
const armnnSerializer::ConstTensor * recurrentToForgetWeights() const
ConcatLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const char *const * EnumNamesLogicalBinaryOperation()
ElementwiseUnaryDescriptorBuilder Builder
const armnnSerializer::ComparisonDescriptor * descriptor() const
const armnnSerializer::FeatureCompatibilityVersions * featureVersions() const
armnnSerializer::DataType dataType() const
const LayerType(& EnumValuesLayerType())[68]
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
float cellIntermediateScale() const
armnnSerializer::LogicalBinaryOperation operation() const
const char *const * EnumNamesReduceOperation()
AdditionLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::RsqrtLayer * layer_as_RsqrtLayer() const
void add_descriptor(flatbuffers::Offset< armnnSerializer::SliceDescriptor > descriptor)
flatbuffers::Offset< UnidirectionalSequenceLstmLayer > Finish()
const armnnSerializer::CastLayer * layer_as_CastLayer() const
LstmLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_descriptor(flatbuffers::Offset< armnnSerializer::TransposeDescriptor > descriptor)
flatbuffers::Offset< ActivationLayer > Finish()
BatchNormalizationLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Pooling3dDescriptor Table
bool VerifyLayerVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector< flatbuffers::Offset< void >> *values, const flatbuffers::Vector< uint8_t > *types)
void add_descriptor(flatbuffers::Offset< armnnSerializer::BatchToSpaceNdDescriptor > descriptor)
TransposeConvolution2dLayerBuilder Builder
const armnnSerializer::ElementwiseUnaryDescriptor * descriptor() const
void add_descriptor(flatbuffers::Offset< armnnSerializer::GatherDescriptor > descriptor)
flatbuffers::Offset< TransposeConvolution2dLayer > Finish()
armnnSerializer::LayerType layerType() const
const char *const * EnumNamesPaddingMode()
const armnnSerializer::ConstTensor * outputLayerNormWeights() const
const armnnSerializer::ConstTensor * cellLayerNormWeights() const
void add_quantizationScale(float quantizationScale)
flatbuffers::Offset< MaximumLayer > Finish()
Pooling3dLayerBuilder Builder
const DataType(& EnumValuesDataType())[11]
flatbuffers::Offset< MergerLayer > CreateMergerLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::OriginsDescriptor > descriptor=0)
flatbuffers::uoffset_t start_
void add_poolHeight(uint32_t poolHeight)
void add_padRight(uint32_t padRight)
flatbuffers::Offset< AbsLayer > CreateAbsLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
flatbuffers::Offset< LstmLayer > CreateLstmLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::LstmDescriptor > descriptor=0, flatbuffers::Offset< armnnSerializer::LstmInputParams > inputParams=0)
uint32_t padRight() const
flatbuffers::Offset< PermuteDescriptor > Finish()
flatbuffers::Offset< L2NormalizationLayer > CreateL2NormalizationLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::L2NormalizationDescriptor > descriptor=0)
flatbuffers::FlatBufferBuilder & fbb_
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::FlatBufferBuilder & fbb_
void add_constantWeights(bool constantWeights)
const armnnSerializer::Convolution2dLayer * layer_as_Convolution2dLayer() const
ConstTensorBuilder Builder
GatherNdLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const flatbuffers::Vector< int16_t > * data() const
const flatbuffers::Vector< uint32_t > * blockShape() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_method(armnnSerializer::ResizeMethod method)
flatbuffers::uoffset_t start_
void add_padTop(uint32_t padTop)
flatbuffers::Offset< TransposeConvolution2dDescriptor > CreateTransposeConvolution2dDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t padLeft=0, uint32_t padRight=0, uint32_t padTop=0, uint32_t padBottom=0, uint32_t strideX=0, uint32_t strideY=0, bool biasEnabled=false, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NCHW)
void add_index(uint32_t index)
flatbuffers::Offset< GatherLayer > Finish()
ShapeLayerBuilder Builder
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
ResizeBilinearLayerBuilder Builder
const flatbuffers::Vector< uint32_t > * dimMappings() const
void add_beta(float beta)
bool VerifyLayer(flatbuffers::Verifier &verifier, const void *obj, Layer type)
SpaceToBatchNdLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
ActivationDescriptorBuilder Builder
void add_poolDepth(uint32_t poolDepth)
const flatbuffers::Vector< int32_t > * end() const
SoftmaxDescriptorBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< LogSoftmaxLayer > Finish()
ShapeLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_weights(flatbuffers::Offset< armnnSerializer::ConstTensor > weights)
uint32_t maxClassesPerDetection() const
Pooling3dDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_biases(flatbuffers::Offset< armnnSerializer::ConstTensor > biases)
void add_descriptor(flatbuffers::Offset< armnnSerializer::FullyConnectedDescriptor > descriptor)
unsigned int Offset(const TensorShape &shape, unsigned int batch, unsigned int height, unsigned int width, unsigned int channels, const DataLayoutIndexed &dataLayout)
SubtractionLayerBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< ResizeDescriptor > CreateResizeDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t targetHeight=0, uint32_t targetWidth=0, armnnSerializer::ResizeMethod method=armnnSerializer::ResizeMethod_NearestNeighbor, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC, bool alignCorners=false, bool halfPixelCenters=false)
flatbuffers::Offset< FillLayer > CreateFillLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::FillDescriptor > descriptor=0)
void add_padLeft(uint32_t padLeft)
const char *const * EnumNamesResizeMethod()
flatbuffers::FlatBufferBuilder & fbb_
SpaceToBatchNdDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const armnnSerializer::UnidirectionalSequenceLstmLayer * layer_as_UnidirectionalSequenceLstmLayer() const
NormalizationDescriptorBuilder Builder
FillDescriptorBuilder Builder
void add_numGroups(uint32_t numGroups)
const char *const * EnumNamesDataLayout()
flatbuffers::Offset< ShortData > CreateShortDataDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< int16_t > *data=nullptr)
flatbuffers::Offset< IntData > CreateIntDataDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< int32_t > *data=nullptr)
void add_normMethodType(armnnSerializer::NormalizationAlgorithmMethod normMethodType)
const char *const * EnumNamesActivationFunction()
MergeLayerBuilder Builder
void add_descriptor(flatbuffers::Offset< armnnSerializer::PadDescriptor > descriptor)
void add_halfPixelCenters(bool halfPixelCenters)
flatbuffers::uoffset_t start_
void add_peepholeEnabled(bool peepholeEnabled)
NormalizationAlgorithmChannel
flatbuffers::FlatBufferBuilder & fbb_
ArgMinMaxDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
bool projectionEnabled() const
Convolution3dDescriptorBuilder Builder
void add_quantizationOffset(int32_t quantizationOffset)
flatbuffers::uoffset_t start_
void add_layerNormEnabled(bool layerNormEnabled)
flatbuffers::uoffset_t start_
flatbuffers::Offset< StackDescriptor > CreateStackDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, uint32_t axis=0, uint32_t numInputs=0, const std::vector< uint32_t > *inputShape=nullptr)
ArgMinMaxDescriptor Table
InputLayerBuilder Builder
flatbuffers::Offset< LogicalBinaryDescriptor > Finish()
GatherLayerBuilder Builder
void add_numClasses(uint32_t numClasses)
flatbuffers::FlatBufferBuilder & fbb_
armnnSerializer::ReduceOperation reduceOperation() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::Offset< DequantizeLayer > Finish()
void add_padLeft(uint32_t padLeft)
ViewsDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
LstmDescriptorBuilder Builder
flatbuffers::Offset< LongData > CreateLongDataDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< int64_t > *data=nullptr)
void add_descriptor(flatbuffers::Offset< armnnSerializer::ActivationDescriptor > descriptor)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
TransposeDescriptorBuilder Builder
SwitchLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_viewSizes(flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::UintVector >>> viewSizes)
void add_projectionEnabled(bool projectionEnabled)
void add_begin(flatbuffers::Offset< flatbuffers::Vector< int32_t >> begin)
const armnnSerializer::ByteData * data_as_ByteData() const
DetectionPostProcessLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::ShapeLayer * layer_as_ShapeLayer() const
flatbuffers::uoffset_t start_
void add_targetWidth(uint32_t targetWidth)
armnnSerializer::Layer layer_type() const
flatbuffers::uoffset_t start_
const armnnSerializer::ElementwiseUnaryLayer * layer_as_ElementwiseUnaryLayer() const
flatbuffers::FlatBufferBuilder & fbb_
void add_descriptor(flatbuffers::Offset< armnnSerializer::LogicalBinaryDescriptor > descriptor)
StandInLayerBuilder Builder
int32_t ellipsisMask() const
const armnnSerializer::ConstTensor * gamma() const
flatbuffers::Offset< GatherLayer > CreateGatherLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::GatherDescriptor > descriptor=0)
Pooling2dLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_descriptor(flatbuffers::Offset< armnnSerializer::ElementwiseUnaryDescriptor > descriptor)
const armnnSerializer::SpaceToBatchNdDescriptor * descriptor() const
const armnnSerializer::PadDescriptor * descriptor() const
DivisionLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_descriptor(flatbuffers::Offset< armnnSerializer::StackDescriptor > descriptor)
const armnnSerializer::ReduceDescriptor * descriptor() const
void add_strideX(uint32_t strideX)
VT_RECURRENTTOINPUTWEIGHTS
flatbuffers::Offset< RankLayer > CreateRankLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
const armnnSerializer::ConstTensor * mean() const
const armnnSerializer::SwitchLayer * layer_as_SwitchLayer() const
flatbuffers::Offset< StackLayer > Finish()
const armnnSerializer::Convolution3dDescriptor * descriptor() const
flatbuffers::uoffset_t start_
NormalizationDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_padBottom(uint32_t padBottom)
bool layerNormEnabled() const
flatbuffers::Offset< TransposeLayer > CreateTransposeLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::TransposeDescriptor > descriptor=0)
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
void add_strideY(uint32_t strideY)
TransposeConvolution2dDescriptorBuilder Builder
void add_padBottom(uint32_t padBottom)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const armnnSerializer::ReshapeLayer * layer_as_ReshapeLayer() const
DequantizeLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
FloorLayerBuilder Builder
BindableLayerBaseBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::FlatBufferBuilder & fbb_
GatherDescriptorBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
void add_beginMask(int32_t beginMask)
SoftmaxLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::FlatBufferBuilder & fbb_
const char * EnumNamePoolingAlgorithm(PoolingAlgorithm e)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
BatchNormalizationDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< SpaceToDepthDescriptor > Finish()
uint32_t maxDetections() const
flatbuffers::Offset< ComparisonLayer > CreateComparisonLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ComparisonDescriptor > descriptor=0)
flatbuffers::FlatBufferBuilder & fbb_
SwitchLayerBuilder Builder
flatbuffers::Offset< SpaceToBatchNdLayer > Finish()
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::Offset< SwitchLayer > Finish()
void add_projectionEnabled(bool projectionEnabled)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
BatchToSpaceNdDescriptor Table
PermuteLayerBuilder Builder
void add_strideY(uint32_t strideY)
const char * EnumNameConstTensorData(ConstTensorData e)
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
void add_descriptor(flatbuffers::Offset< armnnSerializer::StridedSliceDescriptor > descriptor)
flatbuffers::uoffset_t start_
InstanceNormalizationLayer Table
void add_padList(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> padList)
flatbuffers::Offset< AdditionLayer > Finish()
MaximumLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const char * EnumNameReduceOperation(ReduceOperation e)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
DepthwiseConvolution2dLayer Table
flatbuffers::Offset< ChannelShuffleLayer > Finish()
void add_padTop(uint32_t padTop)
void add_transposeWeightsMatrix(bool transposeWeightsMatrix)
const armnnSerializer::ConstTensor * inputLayerNormWeights() const
FeatureCompatibilityVersions Table
PreluLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
DequantizeLayerBuilder Builder
void add_keepDims(bool keepDims)
const armnnSerializer::ResizeBilinearLayer * layer_as_ResizeBilinearLayer() const
flatbuffers::Offset< ConstTensor > CreateConstTensor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::TensorInfo > info=0, armnnSerializer::ConstTensorData data_type=armnnSerializer::ConstTensorData_NONE, flatbuffers::Offset< void > data=0)
float nmsIouThreshold() const
void add_dilationZ(uint32_t dilationZ)
QLstmLayerBuilder Builder
void add_crops(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> crops)
flatbuffers::Offset< QuantizeLayer > CreateQuantizeLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::DivisionLayer * layer_as_DivisionLayer() const
const armnnSerializer::TransposeDescriptor * descriptor() const
QLstmDescriptorBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
const flatbuffers::Vector< int32_t > * begin() const
void add_biasEnabled(bool biasEnabled)
const armnnSerializer::Pooling2dLayer * layer_as_Pooling2dLayer() const
MeanDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const PaddingMethod(& EnumValuesPaddingMethod())[2]
StridedSliceLayerBuilder Builder
void add_timeMajor(bool timeMajor)
void add_numInputs(uint32_t numInputs)
Convolution2dDescriptor Table
flatbuffers::Offset< InputSlot > CreateInputSlot(flatbuffers::FlatBufferBuilder &_fbb, uint32_t index=0, const armnnSerializer::Connection *connection=0)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
ResizeBilinearLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< SpaceToDepthDescriptor > CreateSpaceToDepthDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t blockSize=0, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
flatbuffers::FlatBufferBuilder & fbb_
armnnSerializer::NormalizationAlgorithmChannel normChannelType() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
ResizeBilinearDescriptorBuilder Builder
MergerLayerBuilder Builder
flatbuffers::Offset< SerializedGraph > Finish()
flatbuffers::Offset< GatherNdLayer > CreateGatherNdLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
void FinishSerializedGraphBuffer(flatbuffers::FlatBufferBuilder &fbb, flatbuffers::Offset< armnnSerializer::SerializedGraph > root)
flatbuffers::Offset< QuantizedLstmLayer > CreateQuantizedLstmLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::QuantizedLstmInputParams > inputParams=0)
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
void add_axis(uint32_t axis)
QLstmLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::Offset< TransposeDescriptor > CreateTransposeDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint32_t > *dimMappings=nullptr)
OriginsDescriptorBuilder Builder
int32_t layerBindingId() const
flatbuffers::Offset< ResizeBilinearDescriptor > Finish()
flatbuffers::Offset< TransposeDescriptor > CreateTransposeDescriptor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> dimMappings=0)
DepthwiseConvolution2dLayerBuilder Builder
void add_numDimensions(uint32_t numDimensions)
flatbuffers::uoffset_t start_
const flatbuffers::Vector< int8_t > * data() const
Pooling2dDescriptorBuilder Builder
TensorInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_hiddenStateZeroPoint(int32_t hiddenStateZeroPoint)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const armnnSerializer::LogSoftmaxLayer * layer_as_LogSoftmaxLayer() const
flatbuffers::FlatBufferBuilder & fbb_
void add_gamma(float gamma)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::FlatBufferBuilder & fbb_
armnnSerializer::ComparisonOperation operation() const
void add_cellIntermediateScale(float cellIntermediateScale)
flatbuffers::uoffset_t start_
LstmInputParamsBuilder Builder
const armnnSerializer::ResizeLayer * layer_as_ResizeLayer() const
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
void add_dimensionality(uint32_t dimensionality)
const armnnSerializer::ComparisonLayer * layer_as_ComparisonLayer() const
flatbuffers::uoffset_t start_
SliceLayerBuilder Builder
flatbuffers::Offset< DetectionPostProcessDescriptor > CreateDetectionPostProcessDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t maxDetections=0, uint32_t maxClassesPerDetection=0, uint32_t detectionsPerClass=0, float nmsScoreThreshold=0.0f, float nmsIouThreshold=0.0f, uint32_t numClasses=0, bool useRegularNms=false, float scaleX=0.0f, float scaleY=0.0f, float scaleW=0.0f, float scaleH=0.0f)
flatbuffers::Offset< InstanceNormalizationLayer > Finish()
bool constantWeights() const
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
const OutputShapeRounding(& EnumValuesOutputShapeRounding())[2]
const armnnSerializer::SerializedGraph * GetSerializedGraph(const void *buf)
const char *const * EnumNamesLayerType()
flatbuffers::Offset< Pooling3dLayer > CreatePooling3dLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::Pooling3dDescriptor > descriptor=0)
void add_data(flatbuffers::Offset< flatbuffers::Vector< int64_t >> data)
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::LogicalBinaryDescriptor * descriptor() const
flatbuffers::Offset< AnyLayer > CreateAnyLayer(flatbuffers::FlatBufferBuilder &_fbb, armnnSerializer::Layer layer_type=armnnSerializer::Layer_NONE, flatbuffers::Offset< void > layer=0)
GatherDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
MeanLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< OutputLayer > Finish()
flatbuffers::Offset< DepthwiseConvolution2dLayer > CreateDepthwiseConvolution2dLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::DepthwiseConvolution2dDescriptor > descriptor=0, flatbuffers::Offset< armnnSerializer::ConstTensor > weights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > biases=0)
const char * EnumNameLayer(Layer e)
flatbuffers::Offset< MergeLayer > CreateMergeLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
flatbuffers::Offset< SliceLayer > Finish()
const armnnSerializer::FloorLayer * layer_as_FloorLayer() const
BatchNormalizationDescriptorBuilder Builder
L2NormalizationDescriptorBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
StackDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_padFront(uint32_t padFront)
const armnnSerializer::MultiplicationLayer * layer_as_MultiplicationLayer() const
ChannelShuffleLayer Table
StridedSliceLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
const armnnSerializer::TensorInfo * info() const
const armnnSerializer::SoftmaxDescriptor * descriptor() const
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
EqualLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
ReduceLayerBuilder Builder
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
ResizeDescriptorBuilder Builder
void add_activationFunction(armnnSerializer::ActivationFunction activationFunction)
flatbuffers::Offset< SoftmaxLayer > Finish()
const flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::OutputSlot > > * outputSlots() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::Offset< ActivationDescriptor > Finish()
VT_MAXCLASSESPERDETECTION
bool VerifyConstTensorData(flatbuffers::Verifier &verifier, const void *obj, ConstTensorData type)
const flatbuffers::Vector< uint32_t > * targetShape() const
flatbuffers::Offset< QLstmInputParams > CreateQLstmInputParams(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToForgetWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToCellWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToOutputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToForgetWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToCellWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToOutputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > forgetGateBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > outputGateBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToInputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToInputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputGateBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > projectionWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > projectionBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellToInputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellToForgetWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellToOutputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputLayerNormWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > forgetLayerNormWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellLayerNormWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > outputLayerNormWeights=0)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
flatbuffers::Offset< ResizeLayer > Finish()
const armnnSerializer::ConstTensor * cellToForgetWeights() const
ResizeBilinearDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
flatbuffers::Offset< ReshapeDescriptor > Finish()
void add_poolWidth(uint32_t poolWidth)
void add_cifgEnabled(bool cifgEnabled)
const flatbuffers::Vector< uint32_t > * axis() const
flatbuffers::Offset< ShortData > Finish()
void add_inputSlots(flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::InputSlot >>> inputSlots)
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
int32_t shrinkAxisMask() const
void add_biasEnabled(bool biasEnabled)
void add_input(flatbuffers::Offset< armnnSerializer::ConstTensor > input)
const armnnSerializer::LayerBase * base() const
flatbuffers::Offset< TensorInfo > CreateTensorInfo(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> dimensions=0, armnnSerializer::DataType dataType=armnnSerializer::DataType_Float16, float quantizationScale=1.0f, int32_t quantizationOffset=0, flatbuffers::Offset< flatbuffers::Vector< float >> quantizationScales=0, uint32_t quantizationDim=0, uint32_t dimensionality=1, flatbuffers::Offset< flatbuffers::Vector< uint8_t >> dimensionSpecificity=0, bool isConstant=false)
flatbuffers::uoffset_t start_
bool Verify(flatbuffers::Verifier &verifier) const
flatbuffers::FlatBufferBuilder & fbb_
Convolution2dLayerBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
void add_paddingMethod(armnnSerializer::PaddingMethod paddingMethod)
flatbuffers::Offset< ConstantLayer > Finish()
VT_RECURRENTTOOUTPUTWEIGHTS
flatbuffers::uoffset_t start_
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
flatbuffers::Offset< SpaceToBatchNdDescriptor > CreateSpaceToBatchNdDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint32_t > *blockShape=nullptr, const std::vector< uint32_t > *padList=nullptr, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::BindableLayerBase * base() const
const char *const * EnumNamesOutputShapeRounding()
flatbuffers::Offset< FullyConnectedDescriptor > CreateFullyConnectedDescriptor(flatbuffers::FlatBufferBuilder &_fbb, bool biasEnabled=false, bool transposeWeightsMatrix=false, bool constantWeights=true)
flatbuffers::Offset< ElementwiseUnaryLayer > Finish()
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< ComparisonLayer > Finish()
flatbuffers::Offset< TransposeConvolution2dLayer > CreateTransposeConvolution2dLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::TransposeConvolution2dDescriptor > descriptor=0, flatbuffers::Offset< armnnSerializer::ConstTensor > weights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > biases=0)
flatbuffers::Offset< MinimumLayer > Finish()
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
void add_index(uint32_t index)
const armnnSerializer::ActivationLayer * layer_as_ActivationLayer() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const armnnSerializer::DequantizeLayer * layer_as_DequantizeLayer() const
Pooling2dDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
void add_constantTensorsAsInputs(uint32_t constantTensorsAsInputs)
void add_data(flatbuffers::Offset< flatbuffers::Vector< int32_t >> data)
flatbuffers::FlatBufferBuilder & fbb_
const ArgMinMaxFunction(& EnumValuesArgMinMaxFunction())[2]
const armnnSerializer::StandInLayer * layer_as_StandInLayer() const
flatbuffers::Offset< PreluLayer > CreatePreluLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
NormalizationLayerBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
Convolution3dDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_outputIntermediateScale(float outputIntermediateScale)
void add_strideY(uint32_t strideY)
IntDataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
float clippingThresCell() const
const armnnSerializer::BatchToSpaceNdLayer * layer_as_BatchToSpaceNdLayer() const
flatbuffers::Offset< StandInDescriptor > Finish()
bool transposeWeightsMatrix() const
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
uint32_t blockSize() const
void add_padTop(uint32_t padTop)
flatbuffers::Offset< StandInDescriptor > CreateStandInDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t numInputs=0, uint32_t numOutputs=0)
const armnnSerializer::ConstTensor * variance() const
const armnnSerializer::Pooling2dDescriptor * Pooling2dDescriptor
flatbuffers::Offset< NormalizationLayer > Finish()
flatbuffers::Offset< PreluLayer > Finish()
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Connection FLATBUFFERS_FINAL_CLASS
void add_dimMappings(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> dimMappings)
flatbuffers::Offset< ByteData > Finish()
void add_weightsLayoutScheme(uint32_t weightsLayoutScheme)
void add_padTop(uint32_t padTop)
void add_beta(float beta)
flatbuffers::FlatBufferBuilder & fbb_
TransposeConvolution2dDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< TransposeLayer > Finish()
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< GreaterLayer > Finish()
LogSoftmaxLayerBuilder Builder
flatbuffers::Offset< Convolution3dLayer > Finish()
void add_descriptor(flatbuffers::Offset< armnnSerializer::ReduceDescriptor > descriptor)
flatbuffers::FlatBufferBuilder & fbb_
void add_targetHeight(uint32_t targetHeight)
void add_quantizationScales(flatbuffers::Offset< flatbuffers::Vector< float >> quantizationScales)
flatbuffers::Offset< QLstmLayer > Finish()
const armnnSerializer::ArgMinMaxLayer * layer_as_ArgMinMaxLayer() const
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
flatbuffers::Offset< MultiplicationLayer > CreateMultiplicationLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
SpaceToDepthDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_cellClip(float cellClip)
flatbuffers::Offset< DepthToSpaceLayer > CreateDepthToSpaceLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::DepthToSpaceDescriptor > descriptor=0)
void add_strideX(uint32_t strideX)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< InstanceNormalizationLayer > CreateInstanceNormalizationLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::InstanceNormalizationDescriptor > descriptor=0)
flatbuffers::Offset< ReduceLayer > Finish()
const armnnSerializer::Pooling3dLayer * layer_as_Pooling3dLayer() const
flatbuffers::uoffset_t start_
const PaddingMode(& EnumValuesPaddingMode())[3]
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_strideZ(uint32_t strideZ)
QuantizedLstmLayerBuilder Builder
const armnnSerializer::Pooling3dDescriptor * descriptor() const
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::DepthwiseConvolution2dDescriptor * descriptor() const
uint32_t concatAxis() const
ResizeBilinearLayer Table
flatbuffers::uoffset_t start_
flatbuffers::Offset< SliceLayer > CreateSliceLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::SliceDescriptor > descriptor=0)
void add_padBottom(uint32_t padBottom)
armnnSerializer::UnaryOperation operation() const
void add_numOutputs(uint32_t numOutputs)
flatbuffers::FlatBufferBuilder & fbb_
void add_end(flatbuffers::Offset< flatbuffers::Vector< int32_t >> end)
void add_biases(flatbuffers::Offset< armnnSerializer::ConstTensor > biases)
flatbuffers::Offset< TensorInfo > CreateTensorInfoDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint32_t > *dimensions=nullptr, armnnSerializer::DataType dataType=armnnSerializer::DataType_Float16, float quantizationScale=1.0f, int32_t quantizationOffset=0, const std::vector< float > *quantizationScales=nullptr, uint32_t quantizationDim=0, uint32_t dimensionality=1, const std::vector< uint8_t > *dimensionSpecificity=nullptr, bool isConstant=false)
flatbuffers::uoffset_t start_
void add_axis(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> axis)
flatbuffers::Offset< Convolution2dDescriptor > CreateConvolution2dDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t padLeft=0, uint32_t padRight=0, uint32_t padTop=0, uint32_t padBottom=0, uint32_t strideX=0, uint32_t strideY=0, uint32_t dilationX=1, uint32_t dilationY=1, bool biasEnabled=false, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NCHW)
flatbuffers::Offset< PadDescriptor > CreatePadDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint32_t > *padList=nullptr, float padValue=0.0f, armnnSerializer::PaddingMode paddingMode=armnnSerializer::PaddingMode_Constant)
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
flatbuffers::Offset< BatchNormalizationDescriptor > Finish()
StandInDescriptorBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< Pooling3dDescriptor > CreatePooling3dDescriptor(flatbuffers::FlatBufferBuilder &_fbb, armnnSerializer::PoolingAlgorithm poolType=armnnSerializer::PoolingAlgorithm_Max, uint32_t padLeft=0, uint32_t padRight=0, uint32_t padTop=0, uint32_t padBottom=0, uint32_t padFront=0, uint32_t padBack=0, uint32_t poolWidth=0, uint32_t poolHeight=0, uint32_t poolDepth=0, uint32_t strideX=0, uint32_t strideY=0, uint32_t strideZ=0, armnnSerializer::OutputShapeRounding outputShapeRounding=armnnSerializer::OutputShapeRounding_Floor, armnnSerializer::PaddingMethod paddingMethod=armnnSerializer::PaddingMethod_IgnoreValue, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
const char *const * EnumNamesLayer()
void add_biases(flatbuffers::Offset< armnnSerializer::ConstTensor > biases)
flatbuffers::Offset< InputLayer > CreateInputLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::BindableLayerBase > base=0)
void add_axis(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> axis)
Convolution2dDescriptorBuilder Builder
TransposeDescriptor Table
DepthToSpaceDescriptor Table
const armnnSerializer::NormalizationDescriptor * descriptor() const
flatbuffers::Offset< Pooling3dLayer > Finish()
void add_scaleY(float scaleY)
void add_dataType(armnnSerializer::DataType dataType)
const char * SerializedGraphIdentifier()
Pooling3dDescriptorBuilder Builder
bool halfPixelCenters() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::Offset< MultiplicationLayer > Finish()
uint32_t dilationX() const
AdditionLayerBuilder Builder
float clippingThresProj() const
const armnnSerializer::LstmDescriptor * descriptor() const
flatbuffers::Offset< ShortData > CreateShortData(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< int16_t >> data=0)
FullyConnectedDescriptorBuilder Builder
void add_outputSlots(flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::OutputSlot >>> outputSlots)
flatbuffers::Offset< ConcatLayer > CreateConcatLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::OriginsDescriptor > descriptor=0)
flatbuffers::Offset< FillDescriptor > Finish()
flatbuffers::Offset< IntData > Finish()
SpaceToDepthLayerBuilder Builder
const armnnSerializer::ConstTensor * biases() const
Convolution2dDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
DivisionLayerBuilder Builder
ArgMinMaxLayerBuilder Builder
ComparisonDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
const flatbuffers::Vector< uint8_t > * dimensionSpecificity() const
flatbuffers::Offset< LstmDescriptor > Finish()
PreluLayerBuilder Builder
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const armnnSerializer::ReduceLayer * layer_as_ReduceLayer() const
armnnSerializer::PaddingMode paddingMode() const
VT_RECURRENTTOFORGETWEIGHTS
flatbuffers::uoffset_t start_
void add_stride(flatbuffers::Offset< flatbuffers::Vector< int32_t >> stride)
SoftmaxLayerBuilder Builder
void add_axis(uint32_t axis)
bool VerifySizePrefixedSerializedGraphBuffer(flatbuffers::Verifier &verifier)
flatbuffers::FlatBufferBuilder & fbb_
LogicalBinaryDescriptor Table
flatbuffers::Offset< SubtractionLayer > CreateSubtractionLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
void add_cifgEnabled(bool cifgEnabled)
void add_descriptor(flatbuffers::Offset< armnnSerializer::SoftmaxDescriptor > descriptor)
flatbuffers::Offset< EqualLayer > Finish()
flatbuffers::Offset< BindableLayerBase > CreateBindableLayerBase(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, int32_t layerBindingId=0)
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< NormalizationDescriptor > Finish()
QLstmDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const flatbuffers::String * layerName() const
flatbuffers::FlatBufferBuilder & fbb_
ConstantLayerBuilder Builder
uint32_t normSize() const
armnnSerializer::DataLayout dataLayout() const
void add_descriptor(flatbuffers::Offset< armnnSerializer::Convolution3dDescriptor > descriptor)
const armnnSerializer::TransposeConvolution2dLayer * layer_as_TransposeConvolution2dLayer() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::FlatBufferBuilder & fbb_
void add_normChannelType(armnnSerializer::NormalizationAlgorithmChannel normChannelType)
flatbuffers::Offset< ArgMinMaxLayer > CreateArgMinMaxLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ArgMinMaxDescriptor > descriptor=0)
void add_descriptor(flatbuffers::Offset< armnnSerializer::ReshapeDescriptor > descriptor)
const armnnSerializer::BatchToSpaceNdDescriptor * descriptor() const
void add_blockShape(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> blockShape)
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::BatchNormalizationLayer * layer_as_BatchNormalizationLayer() const
const flatbuffers::Vector< uint32_t > * size() const
flatbuffers::uoffset_t start_
flatbuffers::Offset< DepthwiseConvolution2dDescriptor > Finish()
const armnnSerializer::ConstTensor * projectionBias() const
flatbuffers::uoffset_t start_
TransposeConvolution2dLayer Table
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
const armnnSerializer::GreaterLayer * layer_as_GreaterLayer() const
flatbuffers::Offset< LayerBase > Finish()
const flatbuffers::Vector< int32_t > * inputIds() const
flatbuffers::Offset< AbsLayer > Finish()
void add_maxDetections(uint32_t maxDetections)
void add_inputIds(flatbuffers::Offset< flatbuffers::Vector< int32_t >> inputIds)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_padRight(uint32_t padRight)
flatbuffers::uoffset_t start_
armnnSerializer::ActivationFunction activationFunction() const
const armnnSerializer::ConstTensor * cellToInputWeights() const
void add_axis(int32_t axis)
void add_inputIntermediateScale(float inputIntermediateScale)
void add_dimMappings(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> dimMappings)
FullyConnectedLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
void add_padLeft(uint32_t padLeft)
flatbuffers::Offset< QLstmDescriptor > CreateQLstmDescriptor(flatbuffers::FlatBufferBuilder &_fbb, bool cifgEnabled=true, bool peepholeEnabled=false, bool projectionEnabled=false, bool layerNormEnabled=false, float cellClip=0.0f, float projectionClip=0.0f, float inputIntermediateScale=0.0f, float forgetIntermediateScale=0.0f, float cellIntermediateScale=0.0f, float outputIntermediateScale=0.0f, int32_t hiddenStateZeroPoint=0, float hiddenStateScale=0.0f)
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
NormalizationLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_biasEnabled(bool biasEnabled)
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< GreaterLayer > CreateGreaterLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
void add_clippingThresProj(float clippingThresProj)
void add_alpha(float alpha)
flatbuffers::Offset< SpaceToDepthLayer > Finish()
BatchNormalizationLayer Table
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_descriptor(flatbuffers::Offset< armnnSerializer::Pooling2dDescriptor > descriptor)
void add_inputParams(flatbuffers::Offset< armnnSerializer::QuantizedLstmInputParams > inputParams)
StackDescriptorBuilder Builder
uint32_t poolHeight() const
flatbuffers::uoffset_t start_
const armnnSerializer::StridedSliceLayer * layer_as_StridedSliceLayer() const
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
void add_forgetIntermediateScale(float forgetIntermediateScale)
flatbuffers::Offset< ReshapeLayer > CreateReshapeLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ReshapeDescriptor > descriptor=0)
const char * EnumNameActivationFunction(ActivationFunction e)
void add_inputParams(flatbuffers::Offset< armnnSerializer::QLstmInputParams > inputParams)
flatbuffers::Offset< MeanDescriptor > CreateMeanDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint32_t > *axis=nullptr, bool keepDims=false)
armnnSerializer::OutputShapeRounding outputShapeRounding() const
flatbuffers::Offset< ArgMinMaxDescriptor > CreateArgMinMaxDescriptor(flatbuffers::FlatBufferBuilder &_fbb, armnnSerializer::ArgMinMaxFunction argMinMaxFunction=armnnSerializer::ArgMinMaxFunction_Min, int32_t axis=0)
void add_descriptor(flatbuffers::Offset< armnnSerializer::UnidirectionalSequenceLstmDescriptor > descriptor)
flatbuffers::Offset< SoftmaxDescriptor > CreateSoftmaxDescriptor(flatbuffers::FlatBufferBuilder &_fbb, float beta=0.0f, int32_t axis=-1)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
const armnnSerializer::MergerLayer * layer_as_MergerLayer() const
flatbuffers::Offset< AdditionLayer > CreateAdditionLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
flatbuffers::uoffset_t start_
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
FullyConnectedDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_begin(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> begin)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
EqualLayerBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
void add_strideX(uint32_t strideX)
const armnnSerializer::BatchNormalizationDescriptor * descriptor() const
NormalizationDescriptor Table
flatbuffers::Offset< L2NormalizationDescriptor > CreateL2NormalizationDescriptor(flatbuffers::FlatBufferBuilder &_fbb, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NCHW, float eps=1e-12f)
void add_blockSize(uint32_t blockSize)
void add_paddingMode(armnnSerializer::PaddingMode paddingMode)
OutputLayerBuilder Builder
MultiplicationLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
SliceLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const char * EnumNameNormalizationAlgorithmMethod(NormalizationAlgorithmMethod e)
const armnnSerializer::ResizeDescriptor * descriptor() const
void add_biases(flatbuffers::Offset< armnnSerializer::ConstTensor > biases)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< MinimumLayer > CreateMinimumLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
const char *const * EnumNamesDataType()
StridedSliceDescriptor Table
void add_clippingThresCell(float clippingThresCell)
ReshapeDescriptorBuilder Builder
flatbuffers::Offset< ByteData > CreateByteData(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< int8_t >> data=0)
QuantizedLstmInputParamsBuilder Builder
flatbuffers::Offset< RsqrtLayer > Finish()
const armnnSerializer::ActivationDescriptor * descriptor() const
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< FeatureCompatibilityVersions > CreateFeatureCompatibilityVersions(flatbuffers::FlatBufferBuilder &_fbb, uint32_t bindingIdsScheme=0, uint32_t weightsLayoutScheme=0, uint32_t constantTensorsAsInputs=0)
const armnnSerializer::ConstTensor * inputToInputWeights() const
ChannelShuffleLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
const armnnSerializer::ConstantLayer * layer_as_ConstantLayer() const
flatbuffers::Offset< DepthToSpaceDescriptor > CreateDepthToSpaceDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t blockSize=0, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
void add_padList(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> padList)
UnidirectionalSequenceLstmLayer Table
DetectionPostProcessDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const char * EnumNamePaddingMode(PaddingMode e)
const armnnSerializer::DepthToSpaceDescriptor * descriptor() const
MaximumLayerBuilder Builder
flatbuffers::uoffset_t start_
PadDescriptorBuilder Builder
CastLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::ConstTensor * projectionWeights() const
void add_outputShapeRounding(armnnSerializer::OutputShapeRounding outputShapeRounding)
Convolution3dDescriptor Table
FillDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< LstmInputParams > CreateLstmInputParams(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToForgetWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToCellWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToOutputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToForgetWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToCellWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToOutputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > forgetGateBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > outputGateBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToInputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToInputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellToInputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputGateBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > projectionWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > projectionBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellToForgetWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellToOutputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputLayerNormWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > forgetLayerNormWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellLayerNormWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > outputLayerNormWeights=0)
const void * layer() const
uint32_t weightsLayoutScheme() const
const LogicalBinaryOperation(& EnumValuesLogicalBinaryOperation())[2]
const flatbuffers::Vector< int32_t > * stride() const
flatbuffers::uoffset_t start_
const ResizeMethod(& EnumValuesResizeMethod())[2]
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
PermuteDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< CastLayer > CreateCastLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
flatbuffers::uoffset_t start_
void add_variance(flatbuffers::Offset< armnnSerializer::ConstTensor > variance)
flatbuffers::Offset< LayerBase > CreateLayerBase(flatbuffers::FlatBufferBuilder &_fbb, uint32_t index=0, flatbuffers::Offset< flatbuffers::String > layerName=0, armnnSerializer::LayerType layerType=armnnSerializer::LayerType_Addition, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::InputSlot >>> inputSlots=0, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::OutputSlot >>> outputSlots=0)
flatbuffers::uoffset_t start_
flatbuffers::Offset< ShapeLayer > CreateShapeLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
void add_descriptor(flatbuffers::Offset< armnnSerializer::L2NormalizationDescriptor > descriptor)
const char *const * EnumNamesConstTensorData()
void add_argMinMaxFunction(armnnSerializer::ArgMinMaxFunction argMinMaxFunction)
flatbuffers::Offset< QuantizeLayer > Finish()
const ActivationFunction(& EnumValuesActivationFunction())[12]
const armnnSerializer::QuantizedLstmInputParams * inputParams() const
flatbuffers::Offset< LogSoftmaxDescriptor > Finish()
const char *const * EnumNamesNormalizationAlgorithmMethod()
MergeLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::InstanceNormalizationLayer * layer_as_InstanceNormalizationLayer() const
void add_dilationX(uint32_t dilationX)
const armnnSerializer::QuantizedLstmLayer * layer_as_QuantizedLstmLayer() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::Offset< QuantizedLstmInputParams > CreateQuantizedLstmInputParams(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToInputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToForgetWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToCellWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputToOutputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToInputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToForgetWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToCellWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > recurrentToOutputWeights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > inputGateBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > forgetGateBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > cellBias=0, flatbuffers::Offset< armnnSerializer::ConstTensor > outputGateBias=0)
void add_descriptor(flatbuffers::Offset< armnnSerializer::Pooling3dDescriptor > descriptor)
flatbuffers::Offset< ReduceDescriptor > CreateReduceDescriptor(flatbuffers::FlatBufferBuilder &_fbb, bool keepDims=false, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> axis=0, armnnSerializer::ReduceOperation reduceOperation=armnnSerializer::ReduceOperation_Sum)
flatbuffers::Offset< StackDescriptor > CreateStackDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t axis=0, uint32_t numInputs=0, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> inputShape=0)
flatbuffers::Offset< BatchToSpaceNdDescriptor > CreateBatchToSpaceNdDescriptor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> blockShape=0, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> crops=0, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
flatbuffers::uoffset_t start_
const flatbuffers::Vector< uint32_t > * dimensions() const
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::ReshapeDescriptor * descriptor() const
DepthwiseConvolution2dDescriptor Table
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::GatherNdLayer * layer_as_GatherNdLayer() const
void add_inputShape(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> inputShape)
LogicalBinaryLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
QuantizeLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_padRight(uint32_t padRight)
PermuteDescriptorBuilder Builder
LayerBaseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
DepthToSpaceLayerBuilder Builder
const DataLayout(& EnumValuesDataLayout())[4]
flatbuffers::Offset< ResizeDescriptor > Finish()
DepthwiseConvolution2dLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< SplitterLayer > CreateSplitterLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ViewsDescriptor > descriptor=0)
flatbuffers::FlatBufferBuilder & fbb_
ComparisonDescriptorBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
void add_viewOrigins(flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::UintVector >>> viewOrigins)
void add_gamma(flatbuffers::Offset< armnnSerializer::ConstTensor > gamma)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_shrinkAxisMask(int32_t shrinkAxisMask)
flatbuffers::FlatBufferBuilder & fbb_
OriginsDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_peepholeEnabled(bool peepholeEnabled)
SerializedGraphBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< OutputLayer > CreateOutputLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::BindableLayerBase > base=0)
void add_descriptor(flatbuffers::Offset< armnnSerializer::InstanceNormalizationDescriptor > descriptor)
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
flatbuffers::uoffset_t start_
const armnnSerializer::ChannelShuffleDescriptor * descriptor() const
void add_bindingIdsScheme(uint32_t bindingIdsScheme)
flatbuffers::Offset< BatchToSpaceNdLayer > Finish()
StridedSliceDescriptorBuilder Builder
flatbuffers::Offset< SoftmaxLayer > CreateSoftmaxLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::SoftmaxDescriptor > descriptor=0)
void add_descriptor(flatbuffers::Offset< armnnSerializer::LogSoftmaxDescriptor > descriptor)
flatbuffers::Offset< FillDescriptor > CreateFillDescriptor(flatbuffers::FlatBufferBuilder &_fbb, float value=0.0f)
void add_poolType(armnnSerializer::PoolingAlgorithm poolType)
flatbuffers::Offset< ConstTensor > Finish()
flatbuffers::FlatBufferBuilder & fbb_
armnnSerializer::ResizeMethod method() const
const armnnSerializer::Convolution3dLayer * layer_as_Convolution3dLayer() const
const flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::UintVector > > * viewOrigins() const
void add_strideX(uint32_t strideX)
FeatureCompatibilityVersionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
TensorInfoBuilder Builder
void add_inputParams(flatbuffers::Offset< armnnSerializer::LstmInputParams > inputParams)
void add_descriptor(flatbuffers::Offset< armnnSerializer::TransposeConvolution2dDescriptor > descriptor)
flatbuffers::Offset< StridedSliceLayer > CreateStridedSliceLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::StridedSliceDescriptor > descriptor=0)
flatbuffers::uoffset_t start_
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
BatchNormalizationLayerBuilder Builder
flatbuffers::Offset< LogSoftmaxDescriptor > CreateLogSoftmaxDescriptor(flatbuffers::FlatBufferBuilder &_fbb, float beta=1.0f, int32_t axis=-1)
flatbuffers::Offset< SoftmaxDescriptor > Finish()
ResizeBilinearDescriptor Table
flatbuffers::FlatBufferBuilder & fbb_
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::FlatBufferBuilder & fbb_
uint32_t dimensionality() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::PadLayer * layer_as_PadLayer() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::Offset< SliceDescriptor > CreateSliceDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint32_t > *begin=nullptr, const std::vector< uint32_t > *size=nullptr)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_padLeft(uint32_t padLeft)
OutputSlotBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_descriptor(flatbuffers::Offset< armnnSerializer::FillDescriptor > descriptor)
const char *const * EnumNamesNormalizationAlgorithmChannel()
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
LstmDescriptor UnidirectionalSequenceLstmDescriptor
void add_descriptor(flatbuffers::Offset< armnnSerializer::ChannelShuffleDescriptor > descriptor)
DepthToSpaceLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
void add_padBack(uint32_t padBack)
const ComparisonOperation(& EnumValuesComparisonOperation())[6]
flatbuffers::Offset< RsqrtLayer > CreateRsqrtLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
void add_data(flatbuffers::Offset< flatbuffers::Vector< int8_t >> data)
void add_dilationY(uint32_t dilationY)
const flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::UintVector > > * viewSizes() const
void add_axis(int32_t axis)
const armnnSerializer::DepthwiseConvolution2dLayer * layer_as_DepthwiseConvolution2dLayer() const
void add_padRight(uint32_t padRight)
flatbuffers::Offset< FullyConnectedLayer > Finish()
void add_descriptor(flatbuffers::Offset< armnnSerializer::ComparisonDescriptor > descriptor)
flatbuffers::Offset< MeanLayer > CreateMeanLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::MeanDescriptor > descriptor=0)
flatbuffers::Offset< L2NormalizationLayer > Finish()
StridedSliceDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
uint32_t activationFunc() const
DepthToSpaceDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
VT_FORGETINTERMEDIATESCALE
const flatbuffers::Vector< uint32_t > * inputShape() const
uint32_t poolWidth() const
void add_dilationY(uint32_t dilationY)
flatbuffers::Offset< DetectionPostProcessLayer > Finish()
void add_blockShape(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> blockShape)
const armnnSerializer::L2NormalizationDescriptor * descriptor() const
flatbuffers::Offset< ActivationLayer > CreateActivationLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ActivationDescriptor > descriptor=0)
flatbuffers::Offset< SpaceToDepthLayer > CreateSpaceToDepthLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::SpaceToDepthDescriptor > descriptor=0)
flatbuffers::FlatBufferBuilder & fbb_
ElementwiseUnaryLayerBuilder Builder
flatbuffers::Offset< SliceDescriptor > CreateSliceDescriptor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> begin=0, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> size=0)
const armnnSerializer::OriginsDescriptor * origins() const
flatbuffers::uoffset_t start_
TransposeConvolution2dLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
GreaterLayerBuilder Builder
LstmDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
bool useRegularNms() const
flatbuffers::Offset< BatchNormalizationLayer > CreateBatchNormalizationLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::BatchNormalizationDescriptor > descriptor=0, flatbuffers::Offset< armnnSerializer::ConstTensor > mean=0, flatbuffers::Offset< armnnSerializer::ConstTensor > variance=0, flatbuffers::Offset< armnnSerializer::ConstTensor > beta=0, flatbuffers::Offset< armnnSerializer::ConstTensor > gamma=0)
DepthwiseConvolution2dDescriptorBuilder Builder
flatbuffers::Offset< BatchNormalizationDescriptor > CreateBatchNormalizationDescriptor(flatbuffers::FlatBufferBuilder &_fbb, float eps=0.0f, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
ResizeLayerBuilder Builder
flatbuffers::uoffset_t start_
void add_strideX(uint32_t strideX)
const flatbuffers::Vector< int32_t > * outputIds() const
flatbuffers::uoffset_t start_
flatbuffers::Offset< Pooling2dLayer > Finish()
flatbuffers::Offset< ChannelShuffleDescriptor > Finish()
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::Offset< GatherDescriptor > CreateGatherDescriptor(flatbuffers::FlatBufferBuilder &_fbb, int32_t axis=0)
const armnnSerializer::FullyConnectedLayer * layer_as_FullyConnectedLayer() const
flatbuffers::Offset< FillLayer > Finish()
flatbuffers::Offset< Convolution3dLayer > CreateConvolution3dLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::Convolution3dDescriptor > descriptor=0)
flatbuffers::Offset< ActivationDescriptor > CreateActivationDescriptor(flatbuffers::FlatBufferBuilder &_fbb, armnnSerializer::ActivationFunction activationFunction=armnnSerializer::ActivationFunction_Sigmoid, float a=0.0f, float b=0.0f)
void add_descriptor(flatbuffers::Offset< armnnSerializer::ViewsDescriptor > descriptor)
const armnnSerializer::StridedSliceDescriptor * descriptor() const
flatbuffers::uoffset_t start_
flatbuffers::Offset< NormalizationLayer > CreateNormalizationLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::NormalizationDescriptor > descriptor=0)
flatbuffers::Offset< OriginsDescriptor > Finish()
L2NormalizationLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
void add_concatAxis(uint32_t concatAxis)
ReshapeLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::ChannelShuffleLayer * layer_as_ChannelShuffleLayer() const
FeatureCompatibilityVersionsBuilder Builder
flatbuffers::Offset< AnyLayer > Finish()
const char *const * EnumNamesComparisonOperation()
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< ViewsDescriptor > CreateViewsDescriptor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::OriginsDescriptor > origins=0, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::UintVector >>> viewSizes=0)
void add_poolHeight(uint32_t poolHeight)
void add_cifgEnabled(bool cifgEnabled)
flatbuffers::Offset< PermuteDescriptor > CreatePermuteDescriptor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> dimMappings=0)
void add_projectionClip(float projectionClip)
bool peepholeEnabled() const
flatbuffers::uoffset_t start_
const armnnSerializer::TensorInfo * tensorInfo() const
SerializedGraphBuilder Builder
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_strideY(uint32_t strideY)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< SubtractionLayer > Finish()
flatbuffers::Offset< MeanDescriptor > CreateMeanDescriptor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> axis=0, bool keepDims=false)
flatbuffers::FlatBufferBuilder & fbb_
ReduceDescriptorBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
BatchToSpaceNdLayer Table
flatbuffers::Offset< StandInLayer > CreateStandInLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::StandInDescriptor > descriptor=0)
flatbuffers::uoffset_t start_
const armnnSerializer::Pooling2dDescriptor * descriptor() const
void add_padTop(uint32_t padTop)
flatbuffers::FlatBufferBuilder & fbb_
const char * EnumNameResizeMethod(ResizeMethod e)
const armnnSerializer::ConstTensor * forgetGateBias() const
void add_keepDims(bool keepDims)
void add_layerBindingId(int32_t layerBindingId)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_scaleX(float scaleX)
DetectionPostProcessDescriptorBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< ReduceDescriptor > Finish()
SpaceToDepthDescriptorBuilder Builder
const armnnSerializer::Convolution2dDescriptor * descriptor() const
void add_descriptor(flatbuffers::Offset< armnnSerializer::ResizeDescriptor > descriptor)
ChannelShuffleLayerBuilder Builder
void add_outputIds(flatbuffers::Offset< flatbuffers::Vector< int32_t >> outputIds)
void add_operation(armnnSerializer::LogicalBinaryOperation operation)
void add_mean(flatbuffers::Offset< armnnSerializer::ConstTensor > mean)
flatbuffers::Offset< UintVector > Finish()
ActivationDescriptor Table
const armnnSerializer::IntData * data_as_IntData() const
flatbuffers::Offset< StandInLayer > Finish()
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
const armnnSerializer::LogicalBinaryLayer * layer_as_LogicalBinaryLayer() const
float outputIntermediateScale() const
void add_padBack(uint32_t padBack)
GreaterLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::ConstTensor * cellToOutputWeights() const
flatbuffers::uoffset_t start_
flatbuffers::Offset< StridedSliceDescriptor > Finish()
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::ConstTensor * inputToForgetWeights() const
flatbuffers::Offset< Convolution3dDescriptor > Finish()
flatbuffers::Offset< DetectionPostProcessDescriptor > Finish()
flatbuffers::Offset< SwitchLayer > CreateSwitchLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
const armnnSerializer::InputLayer * layer_as_InputLayer() const
uint32_t numOutputs() const
flatbuffers::FlatBufferBuilder & fbb_
VT_RECURRENTTOCELLWEIGHTS
flatbuffers::FlatBufferBuilder & fbb_
const NormalizationAlgorithmMethod(& EnumValuesNormalizationAlgorithmMethod())[2]
flatbuffers::uoffset_t start_
float quantizationScale() const
flatbuffers::Offset< UintVector > CreateUintVectorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint32_t > *data=nullptr)
flatbuffers::Offset< ResizeBilinearDescriptor > CreateResizeBilinearDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t targetWidth=0, uint32_t targetHeight=0, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC, bool alignCorners=false, bool halfPixelCenters=false)
const ConstTensorData(& EnumValuesConstTensorData())[5]
const armnnSerializer::QLstmInputParams * inputParams() const
void add_layerName(flatbuffers::Offset< flatbuffers::String > layerName)
uint32_t numViews() const
const armnnSerializer::GatherLayer * layer_as_GatherLayer() const
L2NormalizationDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< ElementwiseUnaryDescriptor > CreateElementwiseUnaryDescriptor(flatbuffers::FlatBufferBuilder &_fbb, armnnSerializer::UnaryOperation operation=armnnSerializer::UnaryOperation_Abs)
void add_padLeft(uint32_t padLeft)
void add_size(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> size)
void add_padBottom(uint32_t padBottom)
flatbuffers::Offset< Pooling3dDescriptor > Finish()
flatbuffers::uoffset_t start_
flatbuffers::Offset< ReshapeDescriptor > CreateReshapeDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint32_t > *targetShape=nullptr)
const armnnSerializer::SplitterLayer * layer_as_SplitterLayer() const
void add_nmsScoreThreshold(float nmsScoreThreshold)
flatbuffers::uoffset_t start_
void add_padValue(float padValue)
SplitterLayerBuilder Builder
flatbuffers::Offset< BatchNormalizationLayer > Finish()
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
ActivationLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
uint32_t poolDepth() const
flatbuffers::FlatBufferBuilder & fbb_
const char * EnumNameArgMinMaxFunction(ArgMinMaxFunction e)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< Convolution2dDescriptor > Finish()
flatbuffers::Offset< PadDescriptor > CreatePadDescriptor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> padList=0, float padValue=0.0f, armnnSerializer::PaddingMode paddingMode=armnnSerializer::PaddingMode_Constant)
const armnnSerializer::QLstmLayer * layer_as_QLstmLayer() const
void add_useRegularNms(bool useRegularNms)
const armnnSerializer::SpaceToBatchNdLayer * layer_as_SpaceToBatchNdLayer() const
void add_descriptor(flatbuffers::Offset< armnnSerializer::QLstmDescriptor > descriptor)
flatbuffers::Offset< TransposeConvolution2dDescriptor > Finish()
const PoolingAlgorithm(& EnumValuesPoolingAlgorithm())[3]
flatbuffers::Offset< PadLayer > CreatePadLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::PadDescriptor > descriptor=0)
flatbuffers::Offset< FloorLayer > CreateFloorLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
flatbuffers::uoffset_t start_
void add_descriptor(flatbuffers::Offset< armnnSerializer::DepthwiseConvolution2dDescriptor > descriptor)
flatbuffers::Offset< DivisionLayer > Finish()
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_projectionEnabled(bool projectionEnabled)
ComparisonLayerBuilder Builder
uint32_t bindingIdsScheme() const
DetectionPostProcessLayerBuilder Builder
flatbuffers::Offset< NormalizationDescriptor > CreateNormalizationDescriptor(flatbuffers::FlatBufferBuilder &_fbb, armnnSerializer::NormalizationAlgorithmChannel normChannelType=armnnSerializer::NormalizationAlgorithmChannel_Across, armnnSerializer::NormalizationAlgorithmMethod normMethodType=armnnSerializer::NormalizationAlgorithmMethod_LocalBrightness, uint32_t normSize=0, float alpha=0.0f, float beta=0.0f, float k=0.0f, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NCHW)
RankLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::PermuteDescriptor * descriptor() const
uint32_t constantTensorsAsInputs() const
const armnnSerializer::ConstTensor * recurrentToCellWeights() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::uoffset_t start_
FillLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
flatbuffers::Offset< Pooling2dDescriptor > CreatePooling2dDescriptor(flatbuffers::FlatBufferBuilder &_fbb, armnnSerializer::PoolingAlgorithm poolType=armnnSerializer::PoolingAlgorithm_Max, uint32_t padLeft=0, uint32_t padRight=0, uint32_t padTop=0, uint32_t padBottom=0, uint32_t poolWidth=0, uint32_t poolHeight=0, uint32_t strideX=0, uint32_t strideY=0, armnnSerializer::OutputShapeRounding outputShapeRounding=armnnSerializer::OutputShapeRounding_Floor, armnnSerializer::PaddingMethod paddingMethod=armnnSerializer::PaddingMethod_IgnoreValue, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
QLstmInputParamsBuilder Builder
void add_descriptor(flatbuffers::Offset< armnnSerializer::DepthToSpaceDescriptor > descriptor)
SoftmaxDescriptor LogSoftmaxDescriptor
A LogSoftmaxDescriptor for the LogSoftmaxLayer.
flatbuffers::uoffset_t start_
void add_newAxisMask(int32_t newAxisMask)
void add_padBottom(uint32_t padBottom)
flatbuffers::Offset< EqualLayer > CreateEqualLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
LogicalBinaryDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_quantizationDim(uint32_t quantizationDim)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const armnnSerializer::ConstTensor * recurrentToInputWeights() const
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
flatbuffers::Offset< ConstantLayer > CreateConstantLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ConstTensor > input=0)
flatbuffers::Offset< StackDescriptor > Finish()
void add_strideY(uint32_t strideY)
flatbuffers::Offset< FullyConnectedDescriptor > Finish()
BatchNormalizationDescriptor Table
const armnnSerializer::LstmLayer * layer_as_LstmLayer() const
const armnnSerializer::MeanLayer * layer_as_MeanLayer() const
flatbuffers::Offset< ChannelShuffleLayer > CreateChannelShuffleLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ChannelShuffleDescriptor > descriptor=0)
void add_weights(flatbuffers::Offset< armnnSerializer::ConstTensor > weights)
bool alignCorners() const
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
flatbuffers::Offset< ShapeLayer > Finish()
InstanceNormalizationLayerBuilder Builder
flatbuffers::uoffset_t start_
flatbuffers::Offset< UintVector > CreateUintVector(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> data=0)
flatbuffers::uoffset_t start_
flatbuffers::Offset< StackLayer > CreateStackLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::StackDescriptor > descriptor=0)
TransposeLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
TransposeConvolution2dDescriptor Table
void add_descriptor(flatbuffers::Offset< armnnSerializer::DetectionPostProcessDescriptor > descriptor)
ReshapeDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
ArgMinMaxDescriptorBuilder Builder
ResizeLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::FillLayer * layer_as_FillLayer() const
flatbuffers::Offset< ReshapeLayer > Finish()
UintVectorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
LongDataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
UnidirectionalSequenceLstmDescriptorBuilder Builder
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::FlatBufferBuilder & fbb_
void add_descriptor(flatbuffers::Offset< armnnSerializer::OriginsDescriptor > descriptor)
flatbuffers::Offset< ViewsDescriptor > Finish()
ArgMinMaxLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
UnidirectionalSequenceLstmLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
SpaceToBatchNdLayer Table
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
TransposeDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
InstanceNormalizationDescriptor Table
uint32_t targetWidth() const
void add_poolWidth(uint32_t poolWidth)
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
StandInDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_alignCorners(bool alignCorners)
const armnnSerializer::PreluLayer * layer_as_PreluLayer() const
ByteDataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_peepholeEnabled(bool peepholeEnabled)
void add_biasEnabled(bool biasEnabled)
flatbuffers::Offset< StridedSliceLayer > Finish()
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_layerNormEnabled(bool layerNormEnabled)
const armnnSerializer::MeanDescriptor * descriptor() const
flatbuffers::Offset< Convolution2dLayer > CreateConvolution2dLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::Convolution2dDescriptor > descriptor=0, flatbuffers::Offset< armnnSerializer::ConstTensor > weights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > biases=0)
void add_beta(float beta)
const armnnSerializer::SpaceToDepthLayer * layer_as_SpaceToDepthLayer() const
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
flatbuffers::Offset< DepthwiseConvolution2dLayer > Finish()
UnidirectionalSequenceLstmDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
SpaceToBatchNdLayerBuilder Builder
flatbuffers::Offset< UnidirectionalSequenceLstmLayer > CreateUnidirectionalSequenceLstmLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::UnidirectionalSequenceLstmDescriptor > descriptor=0, flatbuffers::Offset< armnnSerializer::LstmInputParams > inputParams=0)
ActivationLayerBuilder Builder
void add_descriptor(flatbuffers::Offset< armnnSerializer::ArgMinMaxDescriptor > descriptor)
const armnnSerializer::SoftmaxLayer * layer_as_SoftmaxLayer() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const armnnSerializer::OutputLayer * layer_as_OutputLayer() const
const armnnSerializer::LstmInputParams * inputParams() const
flatbuffers::Offset< LogicalBinaryLayer > Finish()
flatbuffers::Offset< FloorLayer > Finish()
flatbuffers::Offset< Pooling2dLayer > CreatePooling2dLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::Pooling2dDescriptor > descriptor=0)
const armnnSerializer::ConstTensor * forgetLayerNormWeights() const
void add_scaleH(float scaleH)
UintVectorBuilder Builder
FullyConnectedLayerBuilder Builder
void add_numViews(uint32_t numViews)
void add_strideZ(uint32_t strideZ)
const armnnSerializer::QuantizeLayer * layer_as_QuantizeLayer() const
flatbuffers::Offset< FeatureCompatibilityVersions > Finish()
flatbuffers::Offset< MergerLayer > Finish()
flatbuffers::Offset< SpaceToBatchNdLayer > CreateSpaceToBatchNdLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::SpaceToBatchNdDescriptor > descriptor=0)
void add_descriptor(flatbuffers::Offset< armnnSerializer::Convolution2dDescriptor > descriptor)
flatbuffers::Offset< UnidirectionalSequenceLstmDescriptor > CreateUnidirectionalSequenceLstmDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t activationFunc=0, float clippingThresCell=0.0f, float clippingThresProj=0.0f, bool cifgEnabled=true, bool peepholeEnabled=false, bool projectionEnabled=false, bool layerNormEnabled=false, bool timeMajor=false)
ConstTensorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const flatbuffers::Vector< uint32_t > * crops() const
flatbuffers::uoffset_t start_
const armnnSerializer::DetectionPostProcessLayer * layer_as_DetectionPostProcessLayer() const
const armnnSerializer::FullyConnectedDescriptor * descriptor() const
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
void add_detectionsPerClass(uint32_t detectionsPerClass)
FullyConnectedLayer Table
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::ConstTensor * cellBias() const
Convolution2dLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_operation(armnnSerializer::ComparisonOperation operation)
ChannelShuffleDescriptorBuilder Builder
ChannelShuffleDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
bool VerifyConstTensorDataVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector< flatbuffers::Offset< void >> *values, const flatbuffers::Vector< uint8_t > *types)
int32_t hiddenStateZeroPoint() const
void add_value(float value)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
armnnSerializer::ArgMinMaxFunction argMinMaxFunction() const
InstanceNormalizationDescriptorBuilder Builder
const armnnSerializer::StackDescriptor * descriptor() const
flatbuffers::Offset< BatchToSpaceNdDescriptor > CreateBatchToSpaceNdDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint32_t > *blockShape=nullptr, const std::vector< uint32_t > *crops=nullptr, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
const armnnSerializer::ConstTensor * anchors() const
flatbuffers::uoffset_t start_
void add_descriptor(flatbuffers::Offset< armnnSerializer::LstmDescriptor > descriptor)
flatbuffers::Offset< ComparisonDescriptor > CreateComparisonDescriptor(flatbuffers::FlatBufferBuilder &_fbb, armnnSerializer::ComparisonOperation operation=armnnSerializer::ComparisonOperation_Equal)
flatbuffers::Offset< BatchToSpaceNdDescriptor > Finish()
flatbuffers::uoffset_t start_
const armnnSerializer::SpaceToDepthDescriptor * descriptor() const
flatbuffers::Offset< BindableLayerBase > Finish()
ComparisonDescriptor Table
InstanceNormalizationLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< MaximumLayer > CreateMaximumLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
flatbuffers::FlatBufferBuilder & fbb_
const char * EnumNameComparisonOperation(ComparisonOperation e)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const armnnSerializer::ConstTensor * recurrentToOutputWeights() const
void add_nmsIouThreshold(float nmsIouThreshold)
flatbuffers::uoffset_t start_
void add_alignCorners(bool alignCorners)
uint32_t numDimensions() const
flatbuffers::Offset< LstmLayer > Finish()
const char *const * EnumNamesArgMinMaxFunction()
void add_blockSize(uint32_t blockSize)
flatbuffers::Offset< GatherNdLayer > Finish()
const armnnSerializer::StandInDescriptor * descriptor() const
VT_TRANSPOSEWEIGHTSMATRIX
AbsLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
SplitterLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_base(flatbuffers::Offset< armnnSerializer::BindableLayerBase > base)
const flatbuffers::Vector< float > * quantizationScales() const
flatbuffers::Offset< ByteData > CreateByteDataDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< int8_t > *data=nullptr)
const armnnSerializer::EqualLayer * layer_as_EqualLayer() const
DepthwiseConvolution2dDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< InstanceNormalizationDescriptor > CreateInstanceNormalizationDescriptor(flatbuffers::FlatBufferBuilder &_fbb, float gamma=0.0f, float beta=0.0f, float eps=0.0f, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
void add_dimensions(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> dimensions)
ActivationDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const char *const * EnumNamesPoolingAlgorithm()
AnyLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::OriginsDescriptor * descriptor() const
const armnnSerializer::ShortData * data_as_ShortData() const
BindableLayerBaseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::AbsLayer * layer_as_AbsLayer() const
void add_targetWidth(uint32_t targetWidth)
flatbuffers::uoffset_t start_
flatbuffers::Offset< ArgMinMaxLayer > Finish()
flatbuffers::Offset< MeanDescriptor > Finish()
const armnnSerializer::TransposeConvolution2dDescriptor * descriptor() const
float inputIntermediateScale() const
const armnnSerializer::ConstTensor * inputToCellWeights() const
L2NormalizationDescriptor Table
const flatbuffers::Vector< int32_t > * data() const
ReduceLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const armnnSerializer::MergeLayer * layer_as_MergeLayer() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
Convolution3dLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
VT_INPUTINTERMEDIATESCALE
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
const armnnSerializer::ViewsDescriptor * descriptor() const
void add_layer_type(armnnSerializer::Layer layer_type)
StackLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::uoffset_t start_
LogSoftmaxLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
void add_targetHeight(uint32_t targetHeight)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< IntData > CreateIntData(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< int32_t >> data=0)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const armnnSerializer::SliceDescriptor * descriptor() const
ElementwiseUnaryLayer Table
void add_targetShape(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> targetShape)
flatbuffers::Offset< ArgMinMaxDescriptor > Finish()
void add_padFront(uint32_t padFront)
void add_hiddenStateScale(float hiddenStateScale)
void add_layer(flatbuffers::Offset< void > layer)
StandInLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< ConcatLayer > Finish()
flatbuffers::uoffset_t start_
flatbuffers::Offset< ResizeLayer > CreateResizeLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ResizeDescriptor > descriptor=0)
armnnSerializer::PoolingAlgorithm poolType() const
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::uoffset_t start_
int32_t newAxisMask() const
void add_paddingMethod(armnnSerializer::PaddingMethod paddingMethod)
flatbuffers::uoffset_t start_
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::Offset< FullyConnectedLayer > CreateFullyConnectedLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::FullyConnectedDescriptor > descriptor=0, flatbuffers::Offset< armnnSerializer::ConstTensor > weights=0, flatbuffers::Offset< armnnSerializer::ConstTensor > biases=0)
flatbuffers::Offset< Convolution2dLayer > Finish()
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
const NormalizationAlgorithmChannel(& EnumValuesNormalizationAlgorithmChannel())[2]
const char * EnumNameLogicalBinaryOperation(LogicalBinaryOperation e)
GatherLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
GatherNdLayerBuilder Builder
ComparisonLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
flatbuffers::Offset< DequantizeLayer > CreateDequantizeLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
BatchToSpaceNdDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
StackLayerBuilder Builder
flatbuffers::Offset< ChannelShuffleDescriptor > CreateChannelShuffleDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t axis=0, uint32_t numGroups=0)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< ResizeBilinearLayer > CreateResizeBilinearLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ResizeBilinearDescriptor > descriptor=0)
flatbuffers::Offset< InstanceNormalizationDescriptor > Finish()
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< PadLayer > Finish()
void add_layerType(armnnSerializer::LayerType layerType)
flatbuffers::uoffset_t start_
float forgetIntermediateScale() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_tensorInfo(flatbuffers::Offset< armnnSerializer::TensorInfo > tensorInfo)
flatbuffers::uoffset_t start_
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_weights(flatbuffers::Offset< armnnSerializer::ConstTensor > weights)
uint32_t dilationZ() const
void FinishSizePrefixedSerializedGraphBuffer(flatbuffers::FlatBufferBuilder &fbb, flatbuffers::Offset< armnnSerializer::SerializedGraph > root)
DepthToSpaceDescriptorBuilder Builder
QuantizeLayerBuilder Builder
flatbuffers::Offset< ViewsDescriptor > CreateViewsDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::OriginsDescriptor > origins=0, const std::vector< flatbuffers::Offset< armnnSerializer::UintVector >> *viewSizes=nullptr)
void add_dilationX(uint32_t dilationX)
flatbuffers::FlatBufferBuilder & fbb_
Pooling2dLayerBuilder Builder
flatbuffers::Offset< PadDescriptor > Finish()
flatbuffers::Offset< OutputSlot > Finish()
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
BatchToSpaceNdDescriptorBuilder Builder
flatbuffers::Offset< OriginsDescriptor > CreateOriginsDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, uint32_t concatAxis=0, uint32_t numViews=0, uint32_t numDimensions=0, const std::vector< flatbuffers::Offset< armnnSerializer::UintVector >> *viewOrigins=nullptr)
flatbuffers::uoffset_t start_
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
const char * EnumNameDataType(DataType e)
DetectionPostProcessDescriptor Table
const char * EnumNamePaddingMethod(PaddingMethod e)
flatbuffers::FlatBufferBuilder & fbb_
void add_featureVersions(flatbuffers::Offset< armnnSerializer::FeatureCompatibilityVersions > featureVersions)
void add_padTop(uint32_t padTop)
flatbuffers::Offset< DetectionPostProcessLayer > CreateDetectionPostProcessLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::DetectionPostProcessDescriptor > descriptor=0, flatbuffers::Offset< armnnSerializer::ConstTensor > anchors=0)
const flatbuffers::Vector< int64_t > * data() const
void add_data(flatbuffers::Offset< flatbuffers::Vector< int16_t >> data)
MeanDescriptorBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
PadDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::Offset< StridedSliceDescriptor > CreateStridedSliceDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< int32_t > *begin=nullptr, const std::vector< int32_t > *end=nullptr, const std::vector< int32_t > *stride=nullptr, int32_t beginMask=0, int32_t endMask=0, int32_t shrinkAxisMask=0, int32_t ellipsisMask=0, int32_t newAxisMask=0, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
void add_dataLayout(armnnSerializer::DataLayout dataLayout)
flatbuffers::Offset< Pooling2dDescriptor > Finish()
flatbuffers::uoffset_t start_
void add_clippingThresProj(float clippingThresProj)
ElementwiseUnaryDescriptor Table
SoftmaxDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
LogSoftmaxDescriptor Table
void add_descriptor(flatbuffers::Offset< armnnSerializer::MeanDescriptor > descriptor)
void add_reduceOperation(armnnSerializer::ReduceOperation reduceOperation)
flatbuffers::Offset< SpaceToBatchNdDescriptor > Finish()
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
SpaceToDepthDescriptor Table
flatbuffers::Offset< ComparisonDescriptor > Finish()
flatbuffers::Offset< QuantizedLstmLayer > Finish()
void add_data(flatbuffers::Offset< void > data)
const char * EnumNameOutputShapeRounding(OutputShapeRounding e)
void add_padLeft(uint32_t padLeft)
const armnnSerializer::ConstTensor * beta() const
RsqrtLayerBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
ResizeDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
const char * EnumNameNormalizationAlgorithmChannel(NormalizationAlgorithmChannel e)
SpaceToBatchNdDescriptorBuilder Builder
flatbuffers::Offset< BatchToSpaceNdLayer > CreateBatchToSpaceNdLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::BatchToSpaceNdDescriptor > descriptor=0)
uint32_t numGroups() const
void add_operation(armnnSerializer::UnaryOperation operation)
bool VerifySerializedGraphBuffer(flatbuffers::Verifier &verifier)
LogicalBinaryLayerBuilder Builder
L2NormalizationLayerBuilder Builder
flatbuffers::Offset< SliceDescriptor > Finish()
float nmsScoreThreshold() const
void add_halfPixelCenters(bool halfPixelCenters)
void add_padBottom(uint32_t padBottom)
const flatbuffers::Vector< uint32_t > * begin() const
bool SerializedGraphBufferHasIdentifier(const void *buf)
flatbuffers::Offset< UnidirectionalSequenceLstmDescriptor > Finish()
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::ResizeBilinearDescriptor * descriptor() const
const armnnSerializer::LongData * data_as_LongData() const
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const armnnSerializer::SubtractionLayer * layer_as_SubtractionLayer() const
flatbuffers::uoffset_t start_
SliceDescriptorBuilder Builder
void add_axis(int32_t axis)
flatbuffers::uoffset_t start_
const armnnSerializer::StackLayer * layer_as_StackLayer() const
flatbuffers::Offset< LogSoftmaxLayer > CreateLogSoftmaxLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::LogSoftmaxDescriptor > descriptor=0)
flatbuffers::FlatBufferBuilder & fbb_
void add_beta(flatbuffers::Offset< armnnSerializer::ConstTensor > beta)
const armnnSerializer::LogSoftmaxDescriptor * descriptor() const
flatbuffers::uoffset_t start_
UnidirectionalSequenceLstmDescriptor Table
UnidirectionalSequenceLstmLayerBuilder Builder
armnnSerializer::ConstTensorData data_type() const
void add_descriptor(flatbuffers::Offset< armnnSerializer::PermuteDescriptor > descriptor)
flatbuffers::Offset< StridedSliceDescriptor > CreateStridedSliceDescriptor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< int32_t >> begin=0, flatbuffers::Offset< flatbuffers::Vector< int32_t >> end=0, flatbuffers::Offset< flatbuffers::Vector< int32_t >> stride=0, int32_t beginMask=0, int32_t endMask=0, int32_t shrinkAxisMask=0, int32_t ellipsisMask=0, int32_t newAxisMask=0, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
flatbuffers::Offset< OriginsDescriptor > CreateOriginsDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t concatAxis=0, uint32_t numViews=0, uint32_t numDimensions=0, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::UintVector >>> viewOrigins=0)
flatbuffers::Offset< QLstmLayer > CreateQLstmLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::QLstmDescriptor > descriptor=0, flatbuffers::Offset< armnnSerializer::QLstmInputParams > inputParams=0)
void add_activationFunc(uint32_t activationFunc)
NormalizationAlgorithmMethod
flatbuffers::Offset< RankLayer > Finish()
flatbuffers::uoffset_t start_
void add_axis(int32_t axis)
flatbuffers::FlatBufferBuilder & fbb_
uint32_t quantizationDim() const
flatbuffers::Offset< ReduceDescriptor > CreateReduceDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, bool keepDims=false, const std::vector< uint32_t > *axis=nullptr, armnnSerializer::ReduceOperation reduceOperation=armnnSerializer::ReduceOperation_Sum)
flatbuffers::FlatBufferBuilder & fbb_
const armnnSerializer::ConstTensor * outputGateBias() const
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< LstmDescriptor > CreateLstmDescriptor(flatbuffers::FlatBufferBuilder &_fbb, uint32_t activationFunc=0, float clippingThresCell=0.0f, float clippingThresProj=0.0f, bool cifgEnabled=true, bool peepholeEnabled=false, bool projectionEnabled=false, bool layerNormEnabled=false)
flatbuffers::FlatBufferBuilder & fbb_
const flatbuffers::Vector< uint32_t > * data() const
flatbuffers::Offset< L2NormalizationDescriptor > Finish()
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
const char * SerializedGraphExtension()
const flatbuffers::Vector< uint32_t > * padList() const
void add_strideY(uint32_t strideY)
OutputSlotBuilder Builder
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
flatbuffers::uoffset_t start_
flatbuffers::FlatBufferBuilder & fbb_
BatchToSpaceNdLayerBuilder Builder
flatbuffers::Offset< ElementwiseUnaryLayer > CreateElementwiseUnaryLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::ElementwiseUnaryDescriptor > descriptor=0)
FLATBUFFERS_STRUCT_END(Connection, 8)
flatbuffers::Offset< PermuteLayer > CreatePermuteLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::PermuteDescriptor > descriptor=0)
const ReduceOperation(& EnumValuesReduceOperation())[5]
void add_outputShapeRounding(armnnSerializer::OutputShapeRounding outputShapeRounding)
const armnnSerializer::L2NormalizationLayer * layer_as_L2NormalizationLayer() const
flatbuffers::Offset< GatherDescriptor > Finish()
FloorLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
void add_descriptor(flatbuffers::Offset< armnnSerializer::BatchNormalizationDescriptor > descriptor)
float hiddenStateScale() const
void add_weights(flatbuffers::Offset< armnnSerializer::ConstTensor > weights)
const armnnSerializer::ArgMinMaxDescriptor * descriptor() const
const UnaryOperation(& EnumValuesUnaryOperation())[8]
ShortDataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const char *const * EnumNamesUnaryOperation()
void add_inputParams(flatbuffers::Offset< armnnSerializer::LstmInputParams > inputParams)
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< SpaceToBatchNdDescriptor > CreateSpaceToBatchNdDescriptor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> blockShape=0, flatbuffers::Offset< flatbuffers::Vector< uint32_t >> padList=0, armnnSerializer::DataLayout dataLayout=armnnSerializer::DataLayout_NHWC)
const char * EnumNameLayerType(LayerType e)
InstanceNormalizationDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
const void * data() const
const armnnSerializer::SerializedGraph * GetSizePrefixedSerializedGraph(const void *buf)
flatbuffers::Offset< PermuteDescriptor > CreatePermuteDescriptorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint32_t > *dimMappings=nullptr)
void add_origins(flatbuffers::Offset< armnnSerializer::OriginsDescriptor > origins)
const armnnSerializer::TransposeLayer * layer_as_TransposeLayer() const
const armnnSerializer::InstanceNormalizationDescriptor * descriptor() const
flatbuffers::FlatBufferBuilder & fbb_
PermuteLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::uoffset_t start_
void add_biasEnabled(bool biasEnabled)
flatbuffers::Offset< MergeLayer > Finish()
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< SerializedGraph > CreateSerializedGraph(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::AnyLayer >>> layers=0, flatbuffers::Offset< flatbuffers::Vector< int32_t >> inputIds=0, flatbuffers::Offset< flatbuffers::Vector< int32_t >> outputIds=0, flatbuffers::Offset< armnnSerializer::FeatureCompatibilityVersions > featureVersions=0)
flatbuffers::FlatBufferBuilder & fbb_
void add_dimensionSpecificity(flatbuffers::Offset< flatbuffers::Vector< uint8_t >> dimensionSpecificity)
flatbuffers::Offset< TransposeDescriptor > Finish()
uint32_t detectionsPerClass() const
L2NormalizationLayer Table
void add_dilationX(uint32_t dilationX)
void add_descriptor(flatbuffers::Offset< armnnSerializer::SpaceToDepthDescriptor > descriptor)
const char *const * EnumNamesPaddingMethod()
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
DetectionPostProcessLayer Table
flatbuffers::uoffset_t start_
LogSoftmaxDescriptorBuilder Builder
flatbuffers::FlatBufferBuilder & fbb_
flatbuffers::Offset< ResizeBilinearLayer > Finish()
void add_numInputs(uint32_t numInputs)
void add_descriptor(flatbuffers::Offset< armnnSerializer::OriginsDescriptor > descriptor)
flatbuffers::uoffset_t start_
OutputLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
LogicalBinaryDescriptorBuilder Builder
const flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::AnyLayer > > * layers() const
const char * EnumNameDataLayout(DataLayout e)
VT_FORGETLAYERNORMWEIGHTS
SpaceToDepthDescriptor DepthToSpaceDescriptor
A DepthToSpaceDescriptor for the DepthToSpaceLayer.
void add_beta(float beta)
flatbuffers::Offset< LogicalBinaryDescriptor > CreateLogicalBinaryDescriptor(flatbuffers::FlatBufferBuilder &_fbb, armnnSerializer::LogicalBinaryOperation operation=armnnSerializer::LogicalBinaryOperation_LogicalAnd)
VT_OUTPUTINTERMEDIATESCALE
flatbuffers::Offset< DivisionLayer > CreateDivisionLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0)
armnnSerializer::PaddingMethod paddingMethod() const
MinimumLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
uint32_t numInputs() const
void add_padRight(uint32_t padRight)
SpaceToDepthLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
void add_layers(flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::AnyLayer >>> layers)
const flatbuffers::Vector< flatbuffers::Offset< armnnSerializer::InputSlot > > * inputSlots() const
flatbuffers::Offset< LogicalBinaryLayer > CreateLogicalBinaryLayer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< armnnSerializer::LayerBase > base=0, flatbuffers::Offset< armnnSerializer::LogicalBinaryDescriptor > descriptor=0)
const armnnSerializer::Pooling3dDescriptor * Pooling3dDescriptor
const armnnSerializer::DetectionPostProcessDescriptor * descriptor() const
SpaceToBatchNdDescriptor Table
Pooling2dDescriptor Table
ReshapeLayerBuilder Builder
const armnnSerializer::ConstTensor * input() const
const armnnSerializer::MinimumLayer * layer_as_MinimumLayer() const
flatbuffers::uoffset_t start_
const armnnSerializer::DepthToSpaceLayer * layer_as_DepthToSpaceLayer() const
const armnnSerializer::GatherDescriptor * descriptor() const
void add_padRight(uint32_t padRight)
const armnnSerializer::Connection * connection() const
flatbuffers::FlatBufferBuilder & fbb_
uint32_t dilationY() const
void add_descriptor(flatbuffers::Offset< armnnSerializer::StandInDescriptor > descriptor)
int32_t quantizationOffset() const
flatbuffers::FlatBufferBuilder & fbb_
void add_base(flatbuffers::Offset< armnnSerializer::LayerBase > base)
PadLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
flatbuffers::FlatBufferBuilder & fbb_
void add_data(flatbuffers::Offset< flatbuffers::Vector< uint32_t >> data)