blob: 971621d60cfaa16e97e63be8645f1f2858f59757 [file] [log] [blame]
Mike Kelly8c1701a2019-02-11 17:01:27 +00001//
Teresa Charlin52664732020-06-29 16:27:03 +01002// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
Mike Kelly8c1701a2019-02-11 17:01:27 +00003// SPDX-License-Identifier: MIT
4//
Mike Kelly8c1701a2019-02-11 17:01:27 +00005#include "Serializer.hpp"
Finn Williamsb454c5c2021-02-09 15:56:23 +00006#include "SerializerUtils.hpp"
Saoirse Stewart3166c3e2019-02-18 15:24:53 +00007
Matthew Benthamff130e22020-01-17 11:47:42 +00008#include <armnn/Descriptors.hpp>
9#include <armnn/LstmParams.hpp>
10#include <armnn/QuantizedLstmParams.hpp>
Jan Eilers8eb25602020-03-09 12:13:48 +000011#include <armnn/utility/IgnoreUnused.hpp>
Matthew Sloyan0663d662020-09-14 11:47:26 +010012#include <armnn/utility/NumericCast.hpp>
Saoirse Stewart3166c3e2019-02-18 15:24:53 +000013
Finn Williamsb454c5c2021-02-09 15:56:23 +000014#include <fmt/format.h>
Mike Kelly8c1701a2019-02-11 17:01:27 +000015#include <iostream>
Saoirse Stewart3166c3e2019-02-18 15:24:53 +000016
Mike Kelly8c1701a2019-02-11 17:01:27 +000017using namespace armnn;
18namespace fb = flatbuffers;
Derek Lamberti0028d1b2019-02-20 13:57:42 +000019namespace serializer = armnnSerializer;
Mike Kelly8c1701a2019-02-11 17:01:27 +000020
21namespace armnnSerializer
22{
23
Finn Williams85d36712021-01-26 22:30:06 +000024ISerializer::ISerializer() : pSerializerImpl(new SerializerImpl())
25{
26}
27
28ISerializer::~ISerializer() = default;
29
30ISerializer* ISerializer::CreateRaw()
31{
32 return new ISerializer();
33}
34
35ISerializerPtr ISerializer::Create()
36{
37 return ISerializerPtr(CreateRaw(), &ISerializer::Destroy);
38}
39
40void ISerializer::Destroy(ISerializer* serializer)
41{
42 delete serializer;
43}
44
45void ISerializer::Serialize(const armnn::INetwork& inNetwork)
46{
47 pSerializerImpl->Serialize(inNetwork);
48}
49
50bool ISerializer::SaveSerializedToStream(std::ostream& stream)
51{
52 return pSerializerImpl->SaveSerializedToStream(stream);
53}
54
Mike Kellyaf484012019-02-20 16:53:11 +000055serializer::ActivationFunction GetFlatBufferActivationFunction(armnn::ActivationFunction function)
56{
57 switch (function)
58 {
59 case armnn::ActivationFunction::Sigmoid:
60 return serializer::ActivationFunction::ActivationFunction_Sigmoid;
61 case armnn::ActivationFunction::TanH:
62 return serializer::ActivationFunction::ActivationFunction_TanH;
63 case armnn::ActivationFunction::Linear:
64 return serializer::ActivationFunction::ActivationFunction_Linear;
65 case armnn::ActivationFunction::ReLu:
66 return serializer::ActivationFunction::ActivationFunction_ReLu;
67 case armnn::ActivationFunction::BoundedReLu:
68 return serializer::ActivationFunction::ActivationFunction_BoundedReLu;
69 case armnn::ActivationFunction::LeakyReLu:
70 return serializer::ActivationFunction::ActivationFunction_LeakyReLu;
71 case armnn::ActivationFunction::Abs:
72 return serializer::ActivationFunction::ActivationFunction_Abs;
73 case armnn::ActivationFunction::Sqrt:
74 return serializer::ActivationFunction::ActivationFunction_Sqrt;
75 case armnn::ActivationFunction::Square:
76 return serializer::ActivationFunction::ActivationFunction_Square;
David Monahan3b3c3812020-02-25 09:03:29 +000077 case armnn::ActivationFunction::Elu:
78 return serializer::ActivationFunction::ActivationFunction_Elu;
Colm Donelan03fbeaf2020-02-26 15:39:23 +000079 case armnn::ActivationFunction::HardSwish:
80 return serializer::ActivationFunction::ActivationFunction_HardSwish;
Mike Kellyaf484012019-02-20 16:53:11 +000081 default:
82 return serializer::ActivationFunction::ActivationFunction_Sigmoid;
83 }
84}
85
Narumol Prangnawarat0cfcf232019-09-09 17:16:24 +010086serializer::ArgMinMaxFunction GetFlatBufferArgMinMaxFunction(armnn::ArgMinMaxFunction function)
87{
88 switch (function)
89 {
90 case armnn::ArgMinMaxFunction::Max:
91 return serializer::ArgMinMaxFunction::ArgMinMaxFunction_Max;
92 case armnn::ArgMinMaxFunction::Min:
93 default:
94 return serializer::ArgMinMaxFunction::ArgMinMaxFunction_Min;
95 }
96}
97
Cathal Corbett5aa9fd72022-02-25 15:33:28 +000098uint32_t SerializerStrategy::GetSerializedId(LayerGuid guid)
Saoirse Stewartcb8a3212019-02-14 15:46:10 +000099{
Saoirse Stewartcb8a3212019-02-14 15:46:10 +0000100 if (m_guidMap.empty())
101 {
janeil013fec1ea2019-11-07 09:47:20 +0000102 m_guidMap.insert(std::make_pair(guid, m_layerId));
Saoirse Stewartcb8a3212019-02-14 15:46:10 +0000103 }
104 else if (m_guidMap.find(guid) == m_guidMap.end())
105 {
janeil013fec1ea2019-11-07 09:47:20 +0000106 ++m_layerId;
107 m_guidMap.insert(std::make_pair(guid, m_layerId));
108
Saoirse Stewartcb8a3212019-02-14 15:46:10 +0000109 return m_layerId;
110 }
Saoirse Stewart30211042019-02-18 17:19:16 +0000111 return m_guidMap[guid];
Saoirse Stewartcb8a3212019-02-14 15:46:10 +0000112}
113
Mike Kelly8c1701a2019-02-11 17:01:27 +0000114// Build FlatBuffer for Input Layer
Finn Williamsb454c5c2021-02-09 15:56:23 +0000115void SerializerStrategy::SerializeInputLayer(const armnn::IConnectableLayer* layer, LayerBindingId id, const char* name)
Mike Kelly8c1701a2019-02-11 17:01:27 +0000116{
Jan Eilers8eb25602020-03-09 12:13:48 +0000117 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000118
Mike Kelly8c1701a2019-02-11 17:01:27 +0000119 // Create FlatBuffer BaseLayer
120 auto flatBufferInputBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Input);
121
122 // Create FlatBuffer BindableBaseLayer
123 auto flatBufferInputBindableBaseLayer = serializer::CreateBindableLayerBase(m_flatBufferBuilder,
124 flatBufferInputBaseLayer,
125 id);
Tee Jungaa920c52019-11-05 10:48:25 +0000126 // Push layer binding id to outputIds.
127 m_inputIds.push_back(id);
Mike Kelly8c1701a2019-02-11 17:01:27 +0000128
129 // Create the FlatBuffer InputLayer
130 auto flatBufferInputLayer = serializer::CreateInputLayer(m_flatBufferBuilder, flatBufferInputBindableBaseLayer);
131
132 // Add the AnyLayer to the FlatBufferLayers
133 CreateAnyLayer(flatBufferInputLayer.o, serializer::Layer::Layer_InputLayer);
134}
135
136// Build FlatBuffer for Output Layer
Finn Williamsb454c5c2021-02-09 15:56:23 +0000137void SerializerStrategy::SerializeOutputLayer(const armnn::IConnectableLayer* layer,
138 LayerBindingId id, const char* name)
Mike Kelly8c1701a2019-02-11 17:01:27 +0000139{
Jan Eilers8eb25602020-03-09 12:13:48 +0000140 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000141
Mike Kelly8c1701a2019-02-11 17:01:27 +0000142 // Create FlatBuffer BaseLayer
143 auto flatBufferOutputBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Output);
144
145 // Create FlatBuffer BindableBaseLayer
146 auto flatBufferOutputBindableBaseLayer = serializer::CreateBindableLayerBase(m_flatBufferBuilder,
147 flatBufferOutputBaseLayer,
148 id);
Tee Jungaa920c52019-11-05 10:48:25 +0000149 // Push layer binding id to outputIds.
150 m_outputIds.push_back(id);
Mike Kelly8c1701a2019-02-11 17:01:27 +0000151
152 // Create the FlatBuffer OutputLayer
153 auto flatBufferOutputLayer = serializer::CreateOutputLayer(m_flatBufferBuilder, flatBufferOutputBindableBaseLayer);
154 // Add the AnyLayer to the FlatBufferLayers
155 CreateAnyLayer(flatBufferOutputLayer.o, serializer::Layer::Layer_OutputLayer);
156}
157
Mike Kellyaf484012019-02-20 16:53:11 +0000158// Build FlatBuffer for Activation Layer
Finn Williamsb454c5c2021-02-09 15:56:23 +0000159void SerializerStrategy::SerializeActivationLayer(const armnn::IConnectableLayer* layer,
160 const armnn::ActivationDescriptor& descriptor,
161 const char* name)
Mike Kellyaf484012019-02-20 16:53:11 +0000162{
Jan Eilers8eb25602020-03-09 12:13:48 +0000163 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000164
Mike Kellyaf484012019-02-20 16:53:11 +0000165 // Create FlatBuffer BaseLayer
166 auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Activation);
167
168 // Create the FlatBuffer ActivationDescriptor
169 auto flatBufferDescriptor = CreateActivationDescriptor(m_flatBufferBuilder,
170 GetFlatBufferActivationFunction(descriptor.m_Function),
171 descriptor.m_A,
172 descriptor.m_B);
173
174 // Create the FlatBuffer ActivationLayer
175 auto flatBufferAdditionLayer = CreateActivationLayer(m_flatBufferBuilder,
176 flatBufferBaseLayer,
177 flatBufferDescriptor);
178
179 // Add the AnyLayer to the FlatBufferLayers
180 CreateAnyLayer(flatBufferAdditionLayer.o, serializer::Layer::Layer_ActivationLayer);
181}
182
Mike Kelly8c1701a2019-02-11 17:01:27 +0000183// Build FlatBuffer for Addition Layer
Finn Williamsb454c5c2021-02-09 15:56:23 +0000184void SerializerStrategy::SerializeAdditionLayer(const armnn::IConnectableLayer* layer, const char* name)
Mike Kelly8c1701a2019-02-11 17:01:27 +0000185{
Jan Eilers8eb25602020-03-09 12:13:48 +0000186 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000187
Mike Kelly8c1701a2019-02-11 17:01:27 +0000188 // Create FlatBuffer BaseLayer
189 auto flatBufferAdditionBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Addition);
190
191 // Create the FlatBuffer AdditionLayer
192 auto flatBufferAdditionLayer = serializer::CreateAdditionLayer(m_flatBufferBuilder, flatBufferAdditionBaseLayer);
193
194 // Add the AnyLayer to the FlatBufferLayers
195 CreateAnyLayer(flatBufferAdditionLayer.o, serializer::Layer::Layer_AdditionLayer);
196}
197
Nikhil Rajee391d52019-09-05 17:50:44 +0100198// Build FlatBuffer for ArgMinMax Layer
Finn Williamsb454c5c2021-02-09 15:56:23 +0000199void SerializerStrategy::SerializeArgMinMaxLayer(const armnn::IConnectableLayer *layer,
200 const armnn::ArgMinMaxDescriptor& descriptor,
201 const char *name)
Nikhil Rajee391d52019-09-05 17:50:44 +0100202{
Jan Eilers8eb25602020-03-09 12:13:48 +0000203 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000204
Narumol Prangnawarat0cfcf232019-09-09 17:16:24 +0100205 // Create FlatBuffer BaseLayer
206 auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_ArgMinMax);
207
208 // Create FlatBuffer Descriptor
209 auto flatBufferDescriptor = CreateArgMinMaxDescriptor(m_flatBufferBuilder,
210 GetFlatBufferArgMinMaxFunction(descriptor.m_Function),
211 descriptor.m_Axis);
212
213 // Create FlatBuffer ArgMinMaxLayer
214 auto flatBufferLayer = CreateArgMinMaxLayer(m_flatBufferBuilder,
215 flatBufferBaseLayer,
216 flatBufferDescriptor);
217
218 CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_ArgMinMaxLayer);
Nikhil Rajee391d52019-09-05 17:50:44 +0100219}
220
Nattapat Chaimanowong6b4ed982019-02-26 17:24:13 +0000221// Build FlatBuffer for BatchToSpaceNd Layer
Finn Williamsb454c5c2021-02-09 15:56:23 +0000222void SerializerStrategy::SerializeBatchToSpaceNdLayer(const armnn::IConnectableLayer* layer,
223 const armnn::BatchToSpaceNdDescriptor& descriptor,
224 const char* name)
Nattapat Chaimanowong6b4ed982019-02-26 17:24:13 +0000225{
Jan Eilers8eb25602020-03-09 12:13:48 +0000226 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000227
Nattapat Chaimanowong6b4ed982019-02-26 17:24:13 +0000228 // Create FlatBuffer BaseLayer
229 auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_BatchToSpaceNd);
230
231 std::vector<unsigned int> crops;
232 crops.reserve(descriptor.m_Crops.size() * 2);
233 for (auto& crop : descriptor.m_Crops)
234 {
235 crops.push_back(crop.first);
236 crops.push_back(crop.second);
237 }
238
239 auto flatBufferDescriptor =
240 CreateBatchToSpaceNdDescriptor(m_flatBufferBuilder,
241 m_flatBufferBuilder.CreateVector(descriptor.m_BlockShape),
242 m_flatBufferBuilder.CreateVector(crops),
243 GetFlatBufferDataLayout(descriptor.m_DataLayout));
244
245 auto flatBufferLayer = serializer::CreateBatchToSpaceNdLayer(m_flatBufferBuilder,
246 flatBufferBaseLayer,
247 flatBufferDescriptor);
248
249 CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_BatchToSpaceNdLayer);
250}
251
Finn Williamsb454c5c2021-02-09 15:56:23 +0000252void SerializerStrategy::SerializeBatchNormalizationLayer(
253 const armnn::IConnectableLayer* layer,
254 const armnn::BatchNormalizationDescriptor& batchNormDescriptor,
255 const std::vector<armnn::ConstTensor>& constants,
256 const char* name)
ruoyan018e7fa232019-02-28 15:09:07 +0000257{
Jan Eilers8eb25602020-03-09 12:13:48 +0000258 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000259
Finn Williamsb454c5c2021-02-09 15:56:23 +0000260 const armnn::ConstTensor& mean = constants[0];
261 const armnn::ConstTensor& variance = constants[1];
262 const armnn::ConstTensor& beta = constants[2];
263 const armnn::ConstTensor& gamma = constants[3];
264
ruoyan018e7fa232019-02-28 15:09:07 +0000265 auto fbBatchNormalizationBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_BatchNormalization);
266 auto fbBatchNormalizationDescriptor = serializer::CreateBatchNormalizationDescriptor(
267 m_flatBufferBuilder,
268 batchNormDescriptor.m_Eps,
269 GetFlatBufferDataLayout(batchNormDescriptor.m_DataLayout));
270
271 auto fbMeanConstTensorInfo = CreateConstTensorInfo(mean);
272 auto fbVarianceConstTensorInfo = CreateConstTensorInfo(variance);
273 auto fbBetaConstTensorInfo = CreateConstTensorInfo(beta);
274 auto fbGammaConstTensorInfo = CreateConstTensorInfo(gamma);
275 auto fbBatchNormalizationLayer = serializer::CreateBatchNormalizationLayer(m_flatBufferBuilder,
276 fbBatchNormalizationBaseLayer,
277 fbBatchNormalizationDescriptor,
278 fbMeanConstTensorInfo,
279 fbVarianceConstTensorInfo,
280 fbBetaConstTensorInfo,
281 fbGammaConstTensorInfo);
282
283 CreateAnyLayer(fbBatchNormalizationLayer.o, serializer::Layer::Layer_BatchNormalizationLayer);
284}
285
mathad01b392e982021-04-07 12:07:30 +0100286void SerializerStrategy::SerializeCastLayer(const armnn::IConnectableLayer* layer,
287 const char* name)
288{
289 IgnoreUnused(name);
290
291 auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Cast);
292 auto fbCastLayer = serializer::CreateCastLayer(m_flatBufferBuilder, fbBaseLayer);
293 CreateAnyLayer(fbCastLayer.o, serializer::Layer::Layer_CastLayer);
294}
295
Simon Obute51f67772021-09-03 15:50:13 +0100296void SerializerStrategy::SerializeChannelShuffleLayer(const armnn::IConnectableLayer* layer,
297 const armnn::ChannelShuffleDescriptor& descriptor,
298 const char* name)
299{
300 IgnoreUnused(name);
301 auto fbDescriptor = CreateChannelShuffleDescriptor(m_flatBufferBuilder,
302 descriptor.m_Axis,
303 descriptor.m_NumGroups);
304 auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_ChannelShuffle);
305 auto fbChannelShuffleLayer = serializer::CreateChannelShuffleLayer(m_flatBufferBuilder, fbBaseLayer, fbDescriptor);
306 CreateAnyLayer(fbChannelShuffleLayer.o, serializer::Layer::Layer_ChannelShuffleLayer);
307}
308
Finn Williamsb454c5c2021-02-09 15:56:23 +0000309void SerializerStrategy::SerializeComparisonLayer(const armnn::IConnectableLayer* layer,
Aron Virginas-Tar77bfb5e2019-10-16 17:45:38 +0100310 const armnn::ComparisonDescriptor& descriptor,
311 const char* name)
312{
Jan Eilers8eb25602020-03-09 12:13:48 +0000313 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000314
Aron Virginas-Tare80ebd12019-10-17 16:11:54 +0100315 auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Comparison);
316 auto fbDescriptor = serializer::CreateComparisonDescriptor(
317 m_flatBufferBuilder,
318 GetFlatBufferComparisonOperation(descriptor.m_Operation));
319
320 auto fbLayer = serializer::CreateComparisonLayer(m_flatBufferBuilder, fbBaseLayer, fbDescriptor);
321 CreateAnyLayer(fbLayer.o, serializer::Layer::Layer_ComparisonLayer);
Aron Virginas-Tar77bfb5e2019-10-16 17:45:38 +0100322}
323
Conor Kennedy76277882019-02-26 08:29:54 +0000324// Build FlatBuffer for Constant Layer
Finn Williamsb454c5c2021-02-09 15:56:23 +0000325void SerializerStrategy::SerializeConstantLayer(const armnn::IConnectableLayer* layer,
326 const std::vector<armnn::ConstTensor>& constants,
327 const char* name)
Conor Kennedy76277882019-02-26 08:29:54 +0000328{
Jan Eilers8eb25602020-03-09 12:13:48 +0000329 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000330
Finn Williamsb454c5c2021-02-09 15:56:23 +0000331 armnn::ConstTensor input = constants[0];
332
Conor Kennedy76277882019-02-26 08:29:54 +0000333 // Create FlatBuffer BaseLayer
334 auto flatBufferConstantBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Constant);
335
336 auto flatBufferConstTensorInfo = CreateConstTensorInfo(input);
337
338 // Create the FlatBuffer ConstantLayer
339 auto flatBufferLayer = CreateConstantLayer(m_flatBufferBuilder,
340 flatBufferConstantBaseLayer,
341 flatBufferConstTensorInfo);
342
343 // Add the AnyLayer to the FlatBufferLayers
344 CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_ConstantLayer);
345}
346
Mike Kellya0766c32019-02-19 17:22:07 +0000347// Build FlatBuffer for Convolution2dLayer
Finn Williamsb454c5c2021-02-09 15:56:23 +0000348void SerializerStrategy::SerializeConvolution2dLayer(const armnn::IConnectableLayer* layer,
349 const armnn::Convolution2dDescriptor& descriptor,
350 const std::vector<armnn::ConstTensor>& constants,
351 const char* name)
Mike Kellya0766c32019-02-19 17:22:07 +0000352{
Jan Eilers8eb25602020-03-09 12:13:48 +0000353 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000354
Finn Williamsb454c5c2021-02-09 15:56:23 +0000355 const armnn::ConstTensor weights = constants[0];
356
Mike Kellya0766c32019-02-19 17:22:07 +0000357 // Create FlatBuffer BaseLayer
358 auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Convolution2d);
359
360 auto flatBufferDescriptor = CreateConvolution2dDescriptor(m_flatBufferBuilder,
361 descriptor.m_PadLeft,
362 descriptor.m_PadRight,
363 descriptor.m_PadTop,
364 descriptor.m_PadBottom,
365 descriptor.m_StrideX,
366 descriptor.m_StrideY,
Matthew Benthamacad04e2019-05-13 10:02:45 +0100367 descriptor.m_DilationX,
368 descriptor.m_DilationY,
Mike Kellya0766c32019-02-19 17:22:07 +0000369 descriptor.m_BiasEnabled,
370 GetFlatBufferDataLayout(descriptor.m_DataLayout));
371 auto flatBufferWeightsConstTensorInfo = CreateConstTensorInfo(weights);
372 flatbuffers::Offset<serializer::ConstTensor> flatBufferBiasesConstTensorInfo;
373
Finn Williamsb454c5c2021-02-09 15:56:23 +0000374 if (constants.size() > 1)
Mike Kellya0766c32019-02-19 17:22:07 +0000375 {
Finn Williamsb454c5c2021-02-09 15:56:23 +0000376 const armnn::ConstTensor biases = constants[1];
377 flatBufferBiasesConstTensorInfo = CreateConstTensorInfo(biases);
Mike Kellya0766c32019-02-19 17:22:07 +0000378 }
379
380 // Create the FlatBuffer Convolution2dLayer
381 auto flatBufferLayer = CreateConvolution2dLayer(m_flatBufferBuilder,
382 flatBufferBaseLayer,
383 flatBufferDescriptor,
384 flatBufferWeightsConstTensorInfo,
385 flatBufferBiasesConstTensorInfo);
386
387 // Add the AnyLayer to the FlatBufferLayers
388 CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_Convolution2dLayer);
389}
390
Matthew Sloyan5d7b0a32021-10-18 13:07:49 +0100391// Build FlatBuffer for Convolution3dLayer
Matthew Sloyanb63a3112021-09-08 13:05:51 +0100392void SerializerStrategy::SerializeConvolution3dLayer(const armnn::IConnectableLayer* layer,
393 const armnn::Convolution3dDescriptor& descriptor,
Matthew Sloyanb63a3112021-09-08 13:05:51 +0100394 const char* name)
395{
396 IgnoreUnused(name);
397
Matthew Sloyanb63a3112021-09-08 13:05:51 +0100398 // Create FlatBuffer BaseLayer
Matthew Sloyan5d7b0a32021-10-18 13:07:49 +0100399 auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Convolution3d);
Matthew Sloyanb63a3112021-09-08 13:05:51 +0100400
401 auto flatBufferDescriptor = CreateConvolution3dDescriptor(m_flatBufferBuilder,
402 descriptor.m_PadLeft,
403 descriptor.m_PadRight,
404 descriptor.m_PadTop,
405 descriptor.m_PadBottom,
406 descriptor.m_PadFront,
407 descriptor.m_PadBack,
408 descriptor.m_StrideX,
409 descriptor.m_StrideY,
410 descriptor.m_StrideZ,
411 descriptor.m_DilationX,
412 descriptor.m_DilationY,
413 descriptor.m_DilationZ,
414 descriptor.m_BiasEnabled,
415 GetFlatBufferDataLayout(descriptor.m_DataLayout));
Matthew Sloyanb63a3112021-09-08 13:05:51 +0100416
Matthew Sloyan5d7b0a32021-10-18 13:07:49 +0100417 // Create the FlatBuffer Convolution3dLayer
Matthew Sloyanb63a3112021-09-08 13:05:51 +0100418 auto flatBufferLayer = CreateConvolution3dLayer(m_flatBufferBuilder,
419 flatBufferBaseLayer,
Matthew Sloyan5d7b0a32021-10-18 13:07:49 +0100420 flatBufferDescriptor);
Matthew Sloyanb63a3112021-09-08 13:05:51 +0100421
422 // Add the AnyLayer to the FlatBufferLayers
423 CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_Convolution3dLayer);
424}
425
Finn Williamsb454c5c2021-02-09 15:56:23 +0000426void SerializerStrategy::SerializeDepthToSpaceLayer(const armnn::IConnectableLayer* layer,
Aron Virginas-Tardd6247f2019-09-19 14:31:17 +0100427 const armnn::DepthToSpaceDescriptor& descriptor,
428 const char* name)
429{
Jan Eilers8eb25602020-03-09 12:13:48 +0000430 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000431
Aron Virginas-Tarda9d2d32019-09-20 10:42:02 +0100432 auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_DepthToSpace);
433 auto fbDescriptor = CreateDepthToSpaceDescriptor(m_flatBufferBuilder,
434 descriptor.m_BlockSize,
435 GetFlatBufferDataLayout(descriptor.m_DataLayout));
436
437 auto fbLayer = serializer::CreateDepthToSpaceLayer(m_flatBufferBuilder, fbBaseLayer, fbDescriptor);
438
439 CreateAnyLayer(fbLayer.o, serializer::Layer::Layer_DepthToSpaceLayer);
Aron Virginas-Tardd6247f2019-09-19 14:31:17 +0100440}
441
Finn Williamsb454c5c2021-02-09 15:56:23 +0000442void SerializerStrategy::SerializeDepthwiseConvolution2dLayer(const armnn::IConnectableLayer* layer,
443 const armnn::DepthwiseConvolution2dDescriptor& descriptor,
444 const std::vector<armnn::ConstTensor>& constants,
445 const char* name)
Aron Virginas-Tarc04125f2019-02-19 16:31:08 +0000446{
Jan Eilers8eb25602020-03-09 12:13:48 +0000447 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000448
Finn Williamsb454c5c2021-02-09 15:56:23 +0000449 const armnn::ConstTensor& weights = constants[0];
450
Aron Virginas-Tarc04125f2019-02-19 16:31:08 +0000451 auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_DepthwiseConvolution2d);
452 auto fbDescriptor = CreateDepthwiseConvolution2dDescriptor(m_flatBufferBuilder,
453 descriptor.m_PadLeft,
454 descriptor.m_PadRight,
455 descriptor.m_PadTop,
456 descriptor.m_PadBottom,
457 descriptor.m_StrideX,
458 descriptor.m_StrideY,
Matthew Benthamacad04e2019-05-13 10:02:45 +0100459 descriptor.m_DilationX,
460 descriptor.m_DilationY,
Aron Virginas-Tarc04125f2019-02-19 16:31:08 +0000461 descriptor.m_BiasEnabled,
462 GetFlatBufferDataLayout(descriptor.m_DataLayout));
463
464 flatbuffers::Offset<serializer::ConstTensor> fbWeightsConstTensorInfo = CreateConstTensorInfo(weights);
465 flatbuffers::Offset<serializer::ConstTensor> fbBiasesConstTensorInfo;
Finn Williamsb454c5c2021-02-09 15:56:23 +0000466
467 if (constants.size() > 1)
Aron Virginas-Tarc04125f2019-02-19 16:31:08 +0000468 {
Finn Williamsb454c5c2021-02-09 15:56:23 +0000469 const armnn::ConstTensor& biases = constants[1];
470 fbBiasesConstTensorInfo = CreateConstTensorInfo(biases);
Aron Virginas-Tarc04125f2019-02-19 16:31:08 +0000471 }
472
473 auto flatBufferLayer = CreateDepthwiseConvolution2dLayer(m_flatBufferBuilder,
474 fbBaseLayer,
475 fbDescriptor,
476 fbWeightsConstTensorInfo,
477 fbBiasesConstTensorInfo);
478
479 CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_DepthwiseConvolution2dLayer);
480}
481
Finn Williamsb454c5c2021-02-09 15:56:23 +0000482void SerializerStrategy::SerializeDequantizeLayer(const armnn::IConnectableLayer* layer,
Nattapat Chaimanowonge4294fd2019-03-28 09:56:53 +0000483 const char* name)
484{
Jan Eilers8eb25602020-03-09 12:13:48 +0000485 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000486
Nattapat Chaimanowonge4294fd2019-03-28 09:56:53 +0000487 auto fbDequantizeBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Dequantize);
488 auto fbDequantizeLayer = serializer::CreateDequantizeLayer(m_flatBufferBuilder, fbDequantizeBaseLayer);
489
490 CreateAnyLayer(fbDequantizeLayer.o, serializer::Layer::Layer_DequantizeLayer);
491}
492
Finn Williamsb454c5c2021-02-09 15:56:23 +0000493void SerializerStrategy::SerializeDetectionPostProcessLayer(const armnn::IConnectableLayer* layer,
494 const armnn::DetectionPostProcessDescriptor& descriptor,
495 const std::vector<armnn::ConstTensor>& constants,
496 const char* name)
Nattapat Chaimanowong3e14a9d2019-03-18 12:37:06 +0000497{
Jan Eilers8eb25602020-03-09 12:13:48 +0000498 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000499
Finn Williamsb454c5c2021-02-09 15:56:23 +0000500 const armnn::ConstTensor& anchors = constants[0];
501
Nattapat Chaimanowong3e14a9d2019-03-18 12:37:06 +0000502 auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_DetectionPostProcess);
503 auto fbDescriptor = CreateDetectionPostProcessDescriptor(m_flatBufferBuilder,
504 descriptor.m_MaxDetections,
505 descriptor.m_MaxClassesPerDetection,
506 descriptor.m_DetectionsPerClass,
507 descriptor.m_NmsScoreThreshold,
508 descriptor.m_NmsIouThreshold,
509 descriptor.m_NumClasses,
510 descriptor.m_UseRegularNms,
511 descriptor.m_ScaleX,
512 descriptor.m_ScaleY,
513 descriptor.m_ScaleW,
514 descriptor.m_ScaleH);
515
516 flatbuffers::Offset<serializer::ConstTensor> fbAnchorsConstTensorInfo = CreateConstTensorInfo(anchors);
517
518 auto flatBufferLayer = CreateDetectionPostProcessLayer(m_flatBufferBuilder,
519 fbBaseLayer,
520 fbDescriptor,
521 fbAnchorsConstTensorInfo);
522
523 CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_DetectionPostProcessLayer);
524}
525
Finn Williamsb454c5c2021-02-09 15:56:23 +0000526void SerializerStrategy::SerializeDivisionLayer(const armnn::IConnectableLayer* layer, const char* name)
Éanna Ó Catháin58885892019-02-27 16:16:39 +0000527{
Jan Eilers8eb25602020-03-09 12:13:48 +0000528 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000529
Aron Virginas-Tar0fe32452019-02-28 13:12:47 +0000530 auto fbDivisionBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Division);
531 auto fbDivisionLayer = serializer::CreateDivisionLayer(m_flatBufferBuilder, fbDivisionBaseLayer);
Éanna Ó Catháin58885892019-02-27 16:16:39 +0000532
Aron Virginas-Tar0fe32452019-02-28 13:12:47 +0000533 CreateAnyLayer(fbDivisionLayer.o, serializer::Layer::Layer_DivisionLayer);
534}
Éanna Ó Catháin58885892019-02-27 16:16:39 +0000535
Finn Williamsb454c5c2021-02-09 15:56:23 +0000536void SerializerStrategy::SerializeElementwiseUnaryLayer(const armnn::IConnectableLayer* layer,
josh minor4a3c6102020-01-06 16:40:46 -0600537 const armnn::ElementwiseUnaryDescriptor& descriptor,
538 const char* name)
539{
Jan Eilers8eb25602020-03-09 12:13:48 +0000540 IgnoreUnused(name);
josh minor4a3c6102020-01-06 16:40:46 -0600541
542 auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_ElementwiseUnary);
543 auto fbDescriptor = serializer::CreateElementwiseUnaryDescriptor(
544 m_flatBufferBuilder,
545 GetFlatBufferUnaryOperation(descriptor.m_Operation));
546
547 auto fbLayer = serializer::CreateElementwiseUnaryLayer(m_flatBufferBuilder, fbBaseLayer, fbDescriptor);
548 CreateAnyLayer(fbLayer.o, serializer::Layer::Layer_ElementwiseUnaryLayer);
549}
550
Finn Williamsb454c5c2021-02-09 15:56:23 +0000551void SerializerStrategy::SerializeFillLayer(const armnn::IConnectableLayer* layer,
Ryan OSheaec6c6802020-06-05 17:17:06 +0100552 const armnn::FillDescriptor& fillDescriptor,
553 const char* name)
554{
Ryan OSheaec6c6802020-06-05 17:17:06 +0100555 IgnoreUnused(name);
Keith Davis300ad562020-06-04 16:34:23 +0100556
557 auto fbFillBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Fill);
558
559 auto fbDescriptor = serializer::CreateFillDescriptor(m_flatBufferBuilder, fillDescriptor.m_Value);
560
561 auto fbFillLayer = serializer::CreateFillLayer(m_flatBufferBuilder, fbFillBaseLayer, fbDescriptor);
562
563 CreateAnyLayer(fbFillLayer.o, serializer::Layer::Layer_FillLayer);
Ryan OSheaec6c6802020-06-05 17:17:06 +0100564}
565
Finn Williamsb454c5c2021-02-09 15:56:23 +0000566void SerializerStrategy::SerializeFloorLayer(const armnn::IConnectableLayer *layer, const char *name)
Finn Williamsdd2ba7e2019-03-01 11:51:52 +0000567{
Jan Eilers8eb25602020-03-09 12:13:48 +0000568 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000569
Finn Williamsdd2ba7e2019-03-01 11:51:52 +0000570 auto flatBufferFloorBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Floor);
571 auto flatBufferFloorLayer = serializer::CreateFloorLayer(m_flatBufferBuilder, flatBufferFloorBaseLayer);
572
573 CreateAnyLayer(flatBufferFloorLayer.o, serializer::Layer::Layer_FloorLayer);
574}
575
Finn Williamsb454c5c2021-02-09 15:56:23 +0000576void SerializerStrategy::SerializeGatherLayer(const armnn::IConnectableLayer* layer,
Teresa Charlin52664732020-06-29 16:27:03 +0100577 const armnn::GatherDescriptor& gatherDescriptor,
578 const char* name)
Saoirse Stewarta1ed73a2019-03-04 13:40:12 +0000579{
Jan Eilers8eb25602020-03-09 12:13:48 +0000580 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000581
Teresa Charlin52664732020-06-29 16:27:03 +0100582 auto fbGatherDescriptor = CreateGatherDescriptor(m_flatBufferBuilder,
583 gatherDescriptor.m_Axis);
Matteo Martincighf81edaa2019-03-04 14:34:30 +0000584 auto fbGatherBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Gather);
Teresa Charlin52664732020-06-29 16:27:03 +0100585 auto flatBufferLayer = serializer::CreateGatherLayer(m_flatBufferBuilder, fbGatherBaseLayer, fbGatherDescriptor);
Saoirse Stewarta1ed73a2019-03-04 13:40:12 +0000586
587 CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_GatherLayer);
588}
589
Finn Williamsb454c5c2021-02-09 15:56:23 +0000590void SerializerStrategy::SerializeInstanceNormalizationLayer(
Kevin Mayce5045a2019-10-02 14:07:47 +0100591 const armnn::IConnectableLayer* layer,
592 const armnn::InstanceNormalizationDescriptor& instanceNormalizationDescriptor,
593 const char* name)
594{
Jan Eilers8eb25602020-03-09 12:13:48 +0000595 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000596
Aron Virginas-Tar781ced92019-10-03 11:15:39 +0100597 auto fbDescriptor = serializer::CreateInstanceNormalizationDescriptor(
598 m_flatBufferBuilder,
599 instanceNormalizationDescriptor.m_Gamma,
600 instanceNormalizationDescriptor.m_Beta,
601 instanceNormalizationDescriptor.m_Eps,
602 GetFlatBufferDataLayout(instanceNormalizationDescriptor.m_DataLayout));
603
604 auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_InstanceNormalization);
605 auto fbLayer = serializer::CreateInstanceNormalizationLayer(m_flatBufferBuilder, fbBaseLayer, fbDescriptor);
606
607 CreateAnyLayer(fbLayer.o, serializer::Layer::Layer_InstanceNormalizationLayer);
Kevin Mayce5045a2019-10-02 14:07:47 +0100608}
609
Finn Williamsb454c5c2021-02-09 15:56:23 +0000610void SerializerStrategy::SerializeL2NormalizationLayer(const armnn::IConnectableLayer* layer,
Narumol Prangnawarat495701f2019-03-07 17:31:34 +0000611 const armnn::L2NormalizationDescriptor& l2NormalizationDescriptor,
612 const char* name)
613{
Jan Eilers8eb25602020-03-09 12:13:48 +0000614 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000615
Narumol Prangnawarat495701f2019-03-07 17:31:34 +0000616 // Create FlatBuffer BaseLayer
617 auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_L2Normalization);
618
619 // Create the FlatBuffer L2Normalization Descriptor
620 auto fbDescriptor = serializer::CreateL2NormalizationDescriptor(
Ferran Balaguer0dcffec2019-06-18 16:25:06 +0100621 m_flatBufferBuilder,
622 GetFlatBufferDataLayout(l2NormalizationDescriptor.m_DataLayout),
623 l2NormalizationDescriptor.m_Eps);
Narumol Prangnawarat495701f2019-03-07 17:31:34 +0000624
Ferran Balaguer0dcffec2019-06-18 16:25:06 +0100625 // Create FlatBuffer layer
Narumol Prangnawarat495701f2019-03-07 17:31:34 +0000626 auto fbLayer = serializer::CreateL2NormalizationLayer(m_flatBufferBuilder, fbBaseLayer, fbDescriptor);
627
628 CreateAnyLayer(fbLayer.o, serializer::Layer::Layer_L2NormalizationLayer);
629}
630
Finn Williamsb454c5c2021-02-09 15:56:23 +0000631void SerializerStrategy::SerializeLogicalBinaryLayer(const armnn::IConnectableLayer* layer,
James Conroyaba90cd2020-11-06 16:28:18 +0000632 const armnn::LogicalBinaryDescriptor& descriptor,
633 const char* name)
634{
635 IgnoreUnused(name);
636
637 auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_LogicalBinary);
638 auto fbDescriptor = serializer::CreateLogicalBinaryDescriptor(
639 m_flatBufferBuilder,
640 GetFlatBufferLogicalBinaryOperation(descriptor.m_Operation));
641
642 auto fbLayer = serializer::CreateLogicalBinaryLayer(m_flatBufferBuilder, fbBaseLayer, fbDescriptor);
643 CreateAnyLayer(fbLayer.o, serializer::Layer::Layer_LogicalBinaryLayer);
644}
645
Finn Williamsb454c5c2021-02-09 15:56:23 +0000646void SerializerStrategy::SerializeLogSoftmaxLayer(const armnn::IConnectableLayer* layer,
Aron Virginas-Tarf982dea2019-10-11 14:07:53 +0100647 const armnn::LogSoftmaxDescriptor& logSoftmaxDescriptor,
648 const char* name)
649{
Jan Eilers8eb25602020-03-09 12:13:48 +0000650 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000651
Sadik Armagan26257852019-10-14 13:00:47 +0100652 // Create FlatBuffer BaseLayer
653 auto flatBufferLogSoftmaxBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_LogSoftmax);
654
655 // Create the FlatBuffer LogSoftmaxDescriptor
656 auto flatBufferLogSoftmaxDesc =
657 serializer::CreateLogSoftmaxDescriptor(m_flatBufferBuilder,
658 logSoftmaxDescriptor.m_Beta,
659 logSoftmaxDescriptor.m_Axis);
660
661 // Create the FlatBuffer LogSoftmaxLayer
662 auto flatBufferLogSoftmaxLayer =
663 serializer::CreateLogSoftmaxLayer(m_flatBufferBuilder,
664 flatBufferLogSoftmaxBaseLayer,
665 flatBufferLogSoftmaxDesc);
666
667 CreateAnyLayer(flatBufferLogSoftmaxLayer.o, serializer::Layer::Layer_LogSoftmaxLayer);
Aron Virginas-Tarf982dea2019-10-11 14:07:53 +0100668}
669
Finn Williamsb454c5c2021-02-09 15:56:23 +0000670void SerializerStrategy::SerializeLstmLayer(const armnn::IConnectableLayer* layer,
671 const armnn::LstmDescriptor& descriptor,
672 const std::vector<armnn::ConstTensor>& constants,
673 const char* name)
Jim Flynn11af3752019-03-19 17:22:29 +0000674{
Jan Eilers8eb25602020-03-09 12:13:48 +0000675 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000676
Jim Flynn11af3752019-03-19 17:22:29 +0000677 auto fbLstmBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Lstm);
678
679 auto fbLstmDescriptor = serializer::CreateLstmDescriptor(
680 m_flatBufferBuilder,
681 descriptor.m_ActivationFunc,
682 descriptor.m_ClippingThresCell,
683 descriptor.m_ClippingThresProj,
684 descriptor.m_CifgEnabled,
685 descriptor.m_PeepholeEnabled,
Jan Eilersf8c62972019-07-17 11:07:49 +0100686 descriptor.m_ProjectionEnabled,
687 descriptor.m_LayerNormEnabled);
Jim Flynn11af3752019-03-19 17:22:29 +0000688
Finn Williamsb454c5c2021-02-09 15:56:23 +0000689 // Index for constants vector
690 std::size_t i = 0;
691
692 // Get mandatory/basic input parameters
693 auto inputToForgetWeights = CreateConstTensorInfo(constants[i++]); //InputToForgetWeights
694 auto inputToCellWeights = CreateConstTensorInfo(constants[i++]); //InputToCellWeights
695 auto inputToOutputWeights = CreateConstTensorInfo(constants[i++]); //InputToOutputWeights
696 auto recurrentToForgetWeights = CreateConstTensorInfo(constants[i++]); //RecurrentToForgetWeights
697 auto recurrentToCellWeights = CreateConstTensorInfo(constants[i++]); //RecurrentToCellWeights
698 auto recurrentToOutputWeights = CreateConstTensorInfo(constants[i++]); //RecurrentToOutputWeights
699 auto forgetGateBias = CreateConstTensorInfo(constants[i++]); //ForgetGateBias
700 auto cellBias = CreateConstTensorInfo(constants[i++]); //CellBias
701 auto outputGateBias = CreateConstTensorInfo(constants[i++]); //OutputGateBias
702
703
Jim Flynn11af3752019-03-19 17:22:29 +0000704
705 //Define optional parameters, these will be set depending on configuration in Lstm descriptor
706 flatbuffers::Offset<serializer::ConstTensor> inputToInputWeights;
707 flatbuffers::Offset<serializer::ConstTensor> recurrentToInputWeights;
708 flatbuffers::Offset<serializer::ConstTensor> cellToInputWeights;
709 flatbuffers::Offset<serializer::ConstTensor> inputGateBias;
710 flatbuffers::Offset<serializer::ConstTensor> projectionWeights;
711 flatbuffers::Offset<serializer::ConstTensor> projectionBias;
712 flatbuffers::Offset<serializer::ConstTensor> cellToForgetWeights;
713 flatbuffers::Offset<serializer::ConstTensor> cellToOutputWeights;
Jan Eilersf8c62972019-07-17 11:07:49 +0100714 flatbuffers::Offset<serializer::ConstTensor> inputLayerNormWeights;
715 flatbuffers::Offset<serializer::ConstTensor> forgetLayerNormWeights;
716 flatbuffers::Offset<serializer::ConstTensor> cellLayerNormWeights;
717 flatbuffers::Offset<serializer::ConstTensor> outputLayerNormWeights;
Jim Flynn11af3752019-03-19 17:22:29 +0000718
719 if (!descriptor.m_CifgEnabled)
720 {
Finn Williamsb454c5c2021-02-09 15:56:23 +0000721 inputToInputWeights = CreateConstTensorInfo(constants[i++]); //InputToInputWeights
722 recurrentToInputWeights = CreateConstTensorInfo(constants[i++]); //RecurrentToInputWeights
723 inputGateBias = CreateConstTensorInfo(constants[i++]); //InputGateBias
Jim Flynn11af3752019-03-19 17:22:29 +0000724 }
725
726 if (descriptor.m_PeepholeEnabled)
727 {
Finn Williamsb454c5c2021-02-09 15:56:23 +0000728 if (!descriptor.m_CifgEnabled)
729 {
730 cellToInputWeights = CreateConstTensorInfo(constants[i++]); //CellToInputWeights
731 }
732 cellToForgetWeights = CreateConstTensorInfo(constants[i++]); //CellToForgetWeights
733 cellToOutputWeights = CreateConstTensorInfo(constants[i++]); //CellToOutputWeights
734 }
735
736 if (descriptor.m_ProjectionEnabled)
737 {
738 projectionWeights = CreateConstTensorInfo(constants[i++]); //ProjectionWeights
739 projectionBias = CreateConstTensorInfo(constants[i++]); //ProjectionBias
Jim Flynn11af3752019-03-19 17:22:29 +0000740 }
741
Jan Eilersf8c62972019-07-17 11:07:49 +0100742 if (descriptor.m_LayerNormEnabled)
743 {
744 if (!descriptor.m_CifgEnabled)
745 {
Finn Williamsb454c5c2021-02-09 15:56:23 +0000746 inputLayerNormWeights = CreateConstTensorInfo(constants[i++]); //InputLayerNormWeights
Jan Eilersf8c62972019-07-17 11:07:49 +0100747 }
Finn Williamsb454c5c2021-02-09 15:56:23 +0000748 forgetLayerNormWeights = CreateConstTensorInfo(constants[i++]); //ForgetLayerNormWeights
749 cellLayerNormWeights = CreateConstTensorInfo(constants[i++]); //CellLayerNormWeights
750 outputLayerNormWeights = CreateConstTensorInfo(constants[i++]); //OutputLayerNormWeights
Jan Eilersf8c62972019-07-17 11:07:49 +0100751 }
752
Jim Flynn11af3752019-03-19 17:22:29 +0000753 auto fbLstmParams = serializer::CreateLstmInputParams(
754 m_flatBufferBuilder,
755 inputToForgetWeights,
756 inputToCellWeights,
757 inputToOutputWeights,
758 recurrentToForgetWeights,
759 recurrentToCellWeights,
760 recurrentToOutputWeights,
761 forgetGateBias,
762 cellBias,
763 outputGateBias,
764 inputToInputWeights,
765 recurrentToInputWeights,
766 cellToInputWeights,
767 inputGateBias,
768 projectionWeights,
769 projectionBias,
770 cellToForgetWeights,
Jan Eilersf8c62972019-07-17 11:07:49 +0100771 cellToOutputWeights,
772 inputLayerNormWeights,
773 forgetLayerNormWeights,
774 cellLayerNormWeights,
775 outputLayerNormWeights);
Jim Flynn11af3752019-03-19 17:22:29 +0000776
777 auto fbLstmLayer = serializer::CreateLstmLayer(
778 m_flatBufferBuilder,
779 fbLstmBaseLayer,
780 fbLstmDescriptor,
781 fbLstmParams);
782
783 CreateAnyLayer(fbLstmLayer.o, serializer::Layer::Layer_LstmLayer);
784}
785
Finn Williamsb454c5c2021-02-09 15:56:23 +0000786void SerializerStrategy::SerializeMaximumLayer(const armnn::IConnectableLayer* layer, const char* name)
Sadik Armaganac97c8c2019-03-04 17:44:21 +0000787{
Jan Eilers8eb25602020-03-09 12:13:48 +0000788 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000789
Sadik Armaganac97c8c2019-03-04 17:44:21 +0000790 auto fbMaximumBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Maximum);
791 auto fbMaximumLayer = serializer::CreateMaximumLayer(m_flatBufferBuilder, fbMaximumBaseLayer);
792
793 CreateAnyLayer(fbMaximumLayer.o, serializer::Layer::Layer_MaximumLayer);
794}
795
Finn Williamsb454c5c2021-02-09 15:56:23 +0000796void SerializerStrategy::SerializeMeanLayer(const armnn::IConnectableLayer* layer,
Sadik Armaganac97c8c2019-03-04 17:44:21 +0000797 const armnn::MeanDescriptor& descriptor,
798 const char* name)
799{
Jan Eilers8eb25602020-03-09 12:13:48 +0000800 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000801
Sadik Armaganac97c8c2019-03-04 17:44:21 +0000802 auto fbMeanBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Mean);
803 auto fbMeanDescriptor = serializer::CreateMeanDescriptor(m_flatBufferBuilder,
804 m_flatBufferBuilder.CreateVector(descriptor.m_Axis),
805 descriptor.m_KeepDims);
806
807 auto fbMeanLayer = serializer::CreateMeanLayer(m_flatBufferBuilder,
808 fbMeanBaseLayer,
809 fbMeanDescriptor);
810
811 CreateAnyLayer(fbMeanLayer.o, serializer::Layer::Layer_MeanLayer);
812}
813
Finn Williamsb454c5c2021-02-09 15:56:23 +0000814void SerializerStrategy::SerializeMinimumLayer(const armnn::IConnectableLayer* layer, const char* name)
Sadik Armaganac97c8c2019-03-04 17:44:21 +0000815{
Jan Eilers8eb25602020-03-09 12:13:48 +0000816 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000817
Sadik Armaganac97c8c2019-03-04 17:44:21 +0000818 auto fbMinimumBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Minimum);
819 auto fbMinimumLayer = serializer::CreateMinimumLayer(m_flatBufferBuilder, fbMinimumBaseLayer);
820
821 CreateAnyLayer(fbMinimumLayer.o, serializer::Layer::Layer_MinimumLayer);
822}
823
Finn Williamsb454c5c2021-02-09 15:56:23 +0000824void SerializerStrategy::SerializeMergeLayer(const armnn::IConnectableLayer* layer, const char* name)
Nattapat Chaimanowong1f886302019-04-05 13:37:19 +0100825{
Jan Eilers8eb25602020-03-09 12:13:48 +0000826 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000827
Nattapat Chaimanowong1f886302019-04-05 13:37:19 +0100828 auto fbMergeBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Merge);
829 auto fbMergeLayer = serializer::CreateMergeLayer(m_flatBufferBuilder, fbMergeBaseLayer);
830
831 CreateAnyLayer(fbMergeLayer.o, serializer::Layer::Layer_MergeLayer);
832}
833
Finn Williamsb454c5c2021-02-09 15:56:23 +0000834void SerializerStrategy::SerializeConcatLayer(const armnn::IConnectableLayer* layer,
Jim Flynne242f2d2019-05-22 14:24:13 +0100835 const armnn::ConcatDescriptor& concatDescriptor,
836 const char* name)
837{
Jan Eilers8eb25602020-03-09 12:13:48 +0000838 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000839
Jim Flynne242f2d2019-05-22 14:24:13 +0100840 auto flatBufferConcatBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Concat);
Jim Flynnac25a1b2019-02-28 10:40:49 +0000841
842 std::vector<flatbuffers::Offset<UintVector>> views;
Jim Flynne242f2d2019-05-22 14:24:13 +0100843 for (unsigned int v = 0; v < concatDescriptor.GetNumViews(); ++v)
Jim Flynnac25a1b2019-02-28 10:40:49 +0000844 {
Jim Flynne242f2d2019-05-22 14:24:13 +0100845 const uint32_t* origin = concatDescriptor.GetViewOrigin(v);
Jim Flynnac25a1b2019-02-28 10:40:49 +0000846 std::vector<uint32_t> origins;
Jim Flynne242f2d2019-05-22 14:24:13 +0100847 for (unsigned int d = 0; d < concatDescriptor.GetNumDimensions(); ++d)
Jim Flynnac25a1b2019-02-28 10:40:49 +0000848 {
849 origins.push_back(origin[d]);
850 }
851 auto view = m_flatBufferBuilder.CreateVector(origins);
852 auto uintVector = CreateUintVector(m_flatBufferBuilder, view);
853 views.push_back(uintVector);
854 }
855
Jim Flynne242f2d2019-05-22 14:24:13 +0100856 auto flatBufferConcatDescriptor = CreateOriginsDescriptor(m_flatBufferBuilder,
857 concatDescriptor.GetConcatAxis(),
858 concatDescriptor.GetNumViews(),
859 concatDescriptor.GetNumDimensions(),
Jim Flynnac25a1b2019-02-28 10:40:49 +0000860 m_flatBufferBuilder.CreateVector(views));
861
Jim Flynne242f2d2019-05-22 14:24:13 +0100862 auto flatBufferLayer = CreateConcatLayer(m_flatBufferBuilder,
863 flatBufferConcatBaseLayer,
864 flatBufferConcatDescriptor);
Jim Flynnac25a1b2019-02-28 10:40:49 +0000865
Jim Flynne242f2d2019-05-22 14:24:13 +0100866 CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_ConcatLayer);
Jim Flynnac25a1b2019-02-28 10:40:49 +0000867}
868
Finn Williamsb454c5c2021-02-09 15:56:23 +0000869void SerializerStrategy::SerializeMultiplicationLayer(const armnn::IConnectableLayer* layer, const char* name)
Sadik Armagan5f450272019-02-12 14:31:45 +0000870{
Jan Eilers8eb25602020-03-09 12:13:48 +0000871 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000872
Sadik Armaganac97c8c2019-03-04 17:44:21 +0000873 auto fbMultiplicationBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Multiplication);
874 auto fbMultiplicationLayer = serializer::CreateMultiplicationLayer(m_flatBufferBuilder,
875 fbMultiplicationBaseLayer);
Sadik Armagan5f450272019-02-12 14:31:45 +0000876
Sadik Armaganac97c8c2019-03-04 17:44:21 +0000877 CreateAnyLayer(fbMultiplicationLayer.o, serializer::Layer::Layer_MultiplicationLayer);
Sadik Armagan5f450272019-02-12 14:31:45 +0000878}
879
Finn Williamsb454c5c2021-02-09 15:56:23 +0000880void SerializerStrategy::SerializePadLayer(const armnn::IConnectableLayer* layer,
Nattapat Chaimanowongebb0f9c2019-03-01 12:14:06 +0000881 const armnn::PadDescriptor& padDescriptor,
882 const char* name)
883{
Jan Eilers8eb25602020-03-09 12:13:48 +0000884 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000885
Nattapat Chaimanowongebb0f9c2019-03-01 12:14:06 +0000886 auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Pad);
887
888 std::vector<unsigned int> padList;
889 for (auto& p: padDescriptor.m_PadList)
890 {
891 padList.push_back(p.first);
892 padList.push_back(p.second);
893 }
894
895 auto flatBufferPadDesc = serializer::CreatePadDescriptor(m_flatBufferBuilder,
David Monahan34757812019-06-19 11:47:21 +0100896 m_flatBufferBuilder.CreateVector(padList),
Matthew Sloyan2e5d0b22021-10-21 14:05:31 +0100897 padDescriptor.m_PadValue,
898 GetFlatBufferPaddingMode(padDescriptor.m_PaddingMode));
Nattapat Chaimanowongebb0f9c2019-03-01 12:14:06 +0000899
900 auto flatBufferPadLayer = serializer::CreatePadLayer(m_flatBufferBuilder,
901 flatBufferBaseLayer,
902 flatBufferPadDesc);
903
904 CreateAnyLayer(flatBufferPadLayer.o, serializer::Layer::Layer_PadLayer);
905}
906
Finn Williamsb454c5c2021-02-09 15:56:23 +0000907void SerializerStrategy::SerializePermuteLayer(const armnn::IConnectableLayer* layer,
Nattapat Chaimanowong30b00202019-02-20 17:31:34 +0000908 const armnn::PermuteDescriptor& permuteDescriptor,
909 const char* name)
910{
Jan Eilers8eb25602020-03-09 12:13:48 +0000911 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000912
Nattapat Chaimanowong30b00202019-02-20 17:31:34 +0000913 // Create FlatBuffer BaseLayer
914 auto flatBufferPermuteBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Permute);
915
916 std::vector<unsigned int> dimMappings;
Matthew Jacksondba634f2019-08-15 15:14:18 +0100917 for (unsigned int i=0; i<permuteDescriptor.m_DimMappings.GetSize(); ++i)
Nattapat Chaimanowong30b00202019-02-20 17:31:34 +0000918 {
Matthew Jacksondba634f2019-08-15 15:14:18 +0100919 dimMappings.push_back(permuteDescriptor.m_DimMappings[i]);
Nattapat Chaimanowong30b00202019-02-20 17:31:34 +0000920 }
921
922 auto flatBufferPermuteDesc = serializer::CreatePermuteDescriptor(m_flatBufferBuilder,
923 m_flatBufferBuilder.CreateVector(dimMappings));
924
925 // Create the FlatBuffer PermuteLayer
926 auto flatBufferPermuteLayer = serializer::CreatePermuteLayer(m_flatBufferBuilder,
927 flatBufferPermuteBaseLayer,
928 flatBufferPermuteDesc);
929
930 // Add the AnyLayer to the FlatBufferLayers
931 CreateAnyLayer(flatBufferPermuteLayer.o, serializer::Layer::Layer_PermuteLayer);
932}
933
Finn Williams2605b232020-06-10 15:53:46 +0100934// Build FlatBuffer for Rank Layer
Finn Williamsb454c5c2021-02-09 15:56:23 +0000935void SerializerStrategy::SerializeRankLayer(const armnn::IConnectableLayer* layer,
Finn Williams2605b232020-06-10 15:53:46 +0100936 const char* name)
937{
938 IgnoreUnused(name);
939 auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Rank);
940 auto flatBufferRankLayer = serializer::CreateRankLayer(m_flatBufferBuilder, flatBufferBaseLayer);
941
942 CreateAnyLayer(flatBufferRankLayer.o, serializer::Layer::Layer_RankLayer);
943}
Sadik Armagan0c3ea5b2021-02-03 09:29:30 +0000944
Finn Williamsb454c5c2021-02-09 15:56:23 +0000945void SerializerStrategy::SerializeReduceLayer(const armnn::IConnectableLayer* layer,
946 const armnn::ReduceDescriptor& reduceDescriptor,
947 const char*)
Sadik Armagan0c3ea5b2021-02-03 09:29:30 +0000948{
949 auto fbReduceBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Reduce);
950 auto fbDescriptor = CreateReduceDescriptor(m_flatBufferBuilder,
Sadik Armagan0c3ea5b2021-02-03 09:29:30 +0000951 reduceDescriptor.m_KeepDims,
952 m_flatBufferBuilder.CreateVector(reduceDescriptor.m_vAxis),
953 GetFlatBufferReduceOperation(reduceDescriptor.m_ReduceOperation));
954 auto fbReduceLayer = serializer::CreateReduceLayer(m_flatBufferBuilder,
955 fbReduceBaseLayer,
956 fbDescriptor);
957
958 CreateAnyLayer(fbReduceLayer.o, serializer::Layer::Layer_ReduceLayer);
959}
960
Saoirse Stewart263829c2019-02-19 15:54:14 +0000961// Build FlatBuffer for Reshape Layer
Finn Williamsb454c5c2021-02-09 15:56:23 +0000962void SerializerStrategy::SerializeReshapeLayer(const armnn::IConnectableLayer* layer,
Saoirse Stewart263829c2019-02-19 15:54:14 +0000963 const armnn::ReshapeDescriptor& reshapeDescriptor,
964 const char* name)
965{
Jan Eilers8eb25602020-03-09 12:13:48 +0000966 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000967
Saoirse Stewart263829c2019-02-19 15:54:14 +0000968 // Create FlatBuffer BaseLayer
969 auto flatBufferReshapeBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Reshape);
970
971 std::vector<unsigned int> targetShape;
972 for (unsigned int i =0; i < reshapeDescriptor.m_TargetShape.GetNumDimensions(); i++)
973 {
974 targetShape.push_back(reshapeDescriptor.m_TargetShape[i]);
975 }
976
977 auto flatBufferReshapeDesc = serializer::CreateReshapeDescriptor(m_flatBufferBuilder,
978 m_flatBufferBuilder.CreateVector(targetShape));
979
980 // Create the FlatBuffer ReshapeLayer
981 auto flatBufferReshapeLayer = serializer::CreateReshapeLayer(m_flatBufferBuilder, flatBufferReshapeBaseLayer,
982 flatBufferReshapeDesc);
983
984 // Add the AnyLayer to the FlatBufferLayers
985 CreateAnyLayer(flatBufferReshapeLayer.o, serializer::Layer::Layer_ReshapeLayer);
986}
987
Finn Williamsb454c5c2021-02-09 15:56:23 +0000988void SerializerStrategy::SerializeResizeLayer(const armnn::IConnectableLayer* layer,
Teresa Charlina9075df2019-06-27 15:41:57 +0100989 const armnn::ResizeDescriptor& resizeDescriptor,
990 const char* name)
991{
Jan Eilers8eb25602020-03-09 12:13:48 +0000992 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +0000993
FinnWilliamsArm6fb339a2019-06-28 15:07:10 +0100994 auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Resize);
995
996 auto flatBufferDescriptor =
997 CreateResizeDescriptor(m_flatBufferBuilder,
998 resizeDescriptor.m_TargetHeight,
999 resizeDescriptor.m_TargetWidth,
1000 GetFlatBufferResizeMethod(resizeDescriptor.m_Method),
David Monahan4a0c9b92020-05-30 09:48:39 +01001001 GetFlatBufferDataLayout(resizeDescriptor.m_DataLayout),
1002 resizeDescriptor.m_AlignCorners,
1003 resizeDescriptor.m_HalfPixelCenters);
FinnWilliamsArm6fb339a2019-06-28 15:07:10 +01001004
1005 auto flatBufferLayer = serializer::CreateResizeLayer(m_flatBufferBuilder,
1006 flatBufferBaseLayer,
1007 flatBufferDescriptor);
1008
1009 CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_ResizeLayer);
Teresa Charlina9075df2019-06-27 15:41:57 +01001010}
1011
Finn Williamsb454c5c2021-02-09 15:56:23 +00001012void SerializerStrategy::SerializeSliceLayer(const armnn::IConnectableLayer* layer,
Aron Virginas-Tar636ab402019-09-16 14:27:45 +01001013 const armnn::SliceDescriptor& sliceDescriptor,
1014 const char* name)
1015{
Jan Eilers8eb25602020-03-09 12:13:48 +00001016 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +00001017
Aron Virginas-Tar2fda80b2019-09-18 13:36:52 +01001018 auto fbSliceBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Slice);
1019 auto fbSliceDescriptor = CreateSliceDescriptor(m_flatBufferBuilder,
1020 m_flatBufferBuilder.CreateVector(sliceDescriptor.m_Begin),
1021 m_flatBufferBuilder.CreateVector(sliceDescriptor.m_Size));
1022
1023 auto fbSliceLayer = serializer::CreateSliceLayer(m_flatBufferBuilder, fbSliceBaseLayer, fbSliceDescriptor);
1024
1025 CreateAnyLayer(fbSliceLayer.o, serializer::Layer::Layer_SliceLayer);
Aron Virginas-Tar636ab402019-09-16 14:27:45 +01001026}
1027
Aron Virginas-Tarfc413c02019-02-13 15:41:52 +00001028// Build FlatBuffer for Softmax Layer
Finn Williamsb454c5c2021-02-09 15:56:23 +00001029void SerializerStrategy::SerializeSoftmaxLayer(const armnn::IConnectableLayer* layer,
Derek Lamberti0028d1b2019-02-20 13:57:42 +00001030 const armnn::SoftmaxDescriptor& softmaxDescriptor,
Aron Virginas-Tarfc413c02019-02-13 15:41:52 +00001031 const char* name)
1032{
Jan Eilers8eb25602020-03-09 12:13:48 +00001033 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +00001034
Aron Virginas-Tarfc413c02019-02-13 15:41:52 +00001035 // Create FlatBuffer BaseLayer
1036 auto flatBufferSoftmaxBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Softmax);
1037
1038 // Create the FlatBuffer SoftmaxDescriptor
1039 auto flatBufferSoftmaxDesc =
Sadik Armaganfd0cae32021-11-08 17:18:31 +00001040 serializer::CreateSoftmaxDescriptor(m_flatBufferBuilder,
1041 softmaxDescriptor.m_Beta,
1042 softmaxDescriptor.m_Axis);
Aron Virginas-Tarfc413c02019-02-13 15:41:52 +00001043
1044 // Create the FlatBuffer SoftmaxLayer
1045 auto flatBufferSoftmaxLayer =
1046 serializer::CreateSoftmaxLayer(m_flatBufferBuilder,
1047 flatBufferSoftmaxBaseLayer,
1048 flatBufferSoftmaxDesc);
1049
1050 CreateAnyLayer(flatBufferSoftmaxLayer.o, serializer::Layer::Layer_SoftmaxLayer);
1051}
1052
Finn Williamsb454c5c2021-02-09 15:56:23 +00001053void SerializerStrategy::SerializePooling2dLayer(const armnn::IConnectableLayer* layer,
Derek Lamberti0028d1b2019-02-20 13:57:42 +00001054 const armnn::Pooling2dDescriptor& pooling2dDescriptor,
Saoirse Stewart3166c3e2019-02-18 15:24:53 +00001055 const char* name)
1056{
Jan Eilers8eb25602020-03-09 12:13:48 +00001057 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +00001058
Saoirse Stewart3166c3e2019-02-18 15:24:53 +00001059 auto fbPooling2dBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Pooling2d);
1060 auto fbPooling2dDescriptor = serializer::CreatePooling2dDescriptor(
1061 m_flatBufferBuilder,
1062 GetFlatBufferPoolingAlgorithm(pooling2dDescriptor.m_PoolType),
1063 pooling2dDescriptor.m_PadLeft,
1064 pooling2dDescriptor.m_PadRight,
1065 pooling2dDescriptor.m_PadTop,
1066 pooling2dDescriptor.m_PadBottom,
1067 pooling2dDescriptor.m_PoolWidth,
1068 pooling2dDescriptor.m_PoolHeight,
1069 pooling2dDescriptor.m_StrideX,
1070 pooling2dDescriptor.m_StrideY,
1071 GetFlatBufferOutputShapeRounding(pooling2dDescriptor.m_OutputShapeRounding),
1072 GetFlatBufferPaddingMethod(pooling2dDescriptor.m_PaddingMethod),
1073 GetFlatBufferDataLayout(pooling2dDescriptor.m_DataLayout));
1074
1075 auto fbPooling2dLayer = serializer::CreatePooling2dLayer(m_flatBufferBuilder,
1076 fbPooling2dBaseLayer,
1077 fbPooling2dDescriptor);
1078
1079 CreateAnyLayer(fbPooling2dLayer.o, serializer::Layer::Layer_Pooling2dLayer);
1080}
1081
Tamas Nyirid998a1c2021-11-05 14:55:33 +00001082void SerializerStrategy::SerializePooling3dLayer(const armnn::IConnectableLayer* layer,
1083 const armnn::Pooling3dDescriptor& pooling3dDescriptor,
1084 const char* name)
1085{
1086 IgnoreUnused(name);
1087
1088 auto fbPooling3dBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Pooling3d);
1089 auto fbPooling3dDescriptor = serializer::CreatePooling3dDescriptor(
1090 m_flatBufferBuilder,
1091 GetFlatBufferPoolingAlgorithm(pooling3dDescriptor.m_PoolType),
1092 pooling3dDescriptor.m_PadLeft,
1093 pooling3dDescriptor.m_PadRight,
1094 pooling3dDescriptor.m_PadTop,
1095 pooling3dDescriptor.m_PadBottom,
1096 pooling3dDescriptor.m_PadFront,
1097 pooling3dDescriptor.m_PadBack,
1098 pooling3dDescriptor.m_PoolWidth,
1099 pooling3dDescriptor.m_PoolHeight,
1100 pooling3dDescriptor.m_PoolDepth,
1101 pooling3dDescriptor.m_StrideX,
1102 pooling3dDescriptor.m_StrideY,
1103 pooling3dDescriptor.m_StrideZ,
1104 GetFlatBufferOutputShapeRounding(pooling3dDescriptor.m_OutputShapeRounding),
1105 GetFlatBufferPaddingMethod(pooling3dDescriptor.m_PaddingMethod),
1106 GetFlatBufferDataLayout(pooling3dDescriptor.m_DataLayout));
1107
1108 auto fbPooling3dLayer = serializer::CreatePooling3dLayer(m_flatBufferBuilder,
1109 fbPooling3dBaseLayer,
1110 fbPooling3dDescriptor);
1111
1112 CreateAnyLayer(fbPooling3dLayer.o, serializer::Layer::Layer_Pooling3dLayer);
1113}
1114
Finn Williamsb454c5c2021-02-09 15:56:23 +00001115void SerializerStrategy::SerializePreluLayer(const armnn::IConnectableLayer* layer,
Matteo Martincigh0e406ee2019-06-12 15:42:18 +01001116 const char* name)
1117{
Jan Eilers8eb25602020-03-09 12:13:48 +00001118 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +00001119
Ellen Norris-Thompson51982472019-06-19 11:46:21 +01001120 // Create FlatBuffer BaseLayer
1121 auto flatBufferPreluBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Prelu);
1122
1123 // Create the FlatBuffer AdditionLayer
1124 auto flatBufferPreluLayer = serializer::CreatePreluLayer(m_flatBufferBuilder, flatBufferPreluBaseLayer);
1125
1126 // Add the AnyLayer to the FlatBufferLayers
1127 CreateAnyLayer(flatBufferPreluLayer.o, serializer::Layer::Layer_PreluLayer);
Matteo Martincigh0e406ee2019-06-12 15:42:18 +01001128}
1129
Finn Williamsb454c5c2021-02-09 15:56:23 +00001130void SerializerStrategy::SerializeQuantizeLayer(const armnn::IConnectableLayer *layer, const char *name)
Derek Lamberti87acb272019-03-27 16:51:31 +00001131{
Jan Eilers8eb25602020-03-09 12:13:48 +00001132 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +00001133
Derek Lamberti87acb272019-03-27 16:51:31 +00001134 auto fbQuantizeBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Quantize);
1135 auto fbQuantizeLayer = serializer::CreateQuantizeLayer(m_flatBufferBuilder,
1136 fbQuantizeBaseLayer);
1137 CreateAnyLayer(fbQuantizeLayer.o, serializer::Layer::Layer_QuantizeLayer);
1138}
1139
Sadik Armagandbb0c0c2019-02-21 09:01:41 +00001140// Build FlatBuffer for FullyConnected Layer
Finn Williamsb454c5c2021-02-09 15:56:23 +00001141void SerializerStrategy::SerializeFullyConnectedLayer(const armnn::IConnectableLayer* layer,
1142 const armnn::FullyConnectedDescriptor& fullyConnectedDescriptor,
Sadik Armaganf0a6dec2021-03-25 07:46:55 +00001143 const char*)
Sadik Armagandbb0c0c2019-02-21 09:01:41 +00001144{
1145 // Create FlatBuffer BaseLayer
1146 auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_FullyConnected);
1147
1148 // Create FlatBuffer FullyConnectedDescriptor
1149 auto flatBufferDescriptor =
1150 serializer::CreateFullyConnectedDescriptor(m_flatBufferBuilder,
1151 fullyConnectedDescriptor.m_BiasEnabled,
Sadik Armaganf0a6dec2021-03-25 07:46:55 +00001152 fullyConnectedDescriptor.m_TransposeWeightMatrix,
1153 fullyConnectedDescriptor.m_ConstantWeights);
Sadik Armagandbb0c0c2019-02-21 09:01:41 +00001154
Sadik Armagandbb0c0c2019-02-21 09:01:41 +00001155 // Create FlatBuffer FullyConnectedLayer
1156 auto flatBufferLayer = serializer::CreateFullyConnectedLayer(m_flatBufferBuilder,
1157 flatBufferBaseLayer,
Matthew Sloyan81beae32021-07-13 19:46:11 +01001158 flatBufferDescriptor);
Sadik Armagandbb0c0c2019-02-21 09:01:41 +00001159
1160 // Add created FullyConnectedLayer to the FlatBufferLayers
1161 CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_FullyConnectedLayer);
1162}
1163
Nattapat Chaimanowong45286992019-02-26 15:53:02 +00001164// Build FlatBuffer for SpaceToBatchNd Layer
Finn Williamsb454c5c2021-02-09 15:56:23 +00001165void SerializerStrategy::SerializeSpaceToBatchNdLayer(const armnn::IConnectableLayer* layer,
Nattapat Chaimanowong45286992019-02-26 15:53:02 +00001166 const armnn::SpaceToBatchNdDescriptor& spaceToBatchNdDescriptor,
1167 const char* name)
1168{
Jan Eilers8eb25602020-03-09 12:13:48 +00001169 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +00001170
Nattapat Chaimanowong45286992019-02-26 15:53:02 +00001171 // Create FlatBuffer BaseLayer
1172 auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_SpaceToBatchNd);
1173
1174 std::vector<unsigned int> padList;
1175 padList.reserve(spaceToBatchNdDescriptor.m_PadList.size()*2);
1176 for (auto& pad : spaceToBatchNdDescriptor.m_PadList)
1177 {
1178 padList.push_back(pad.first);
1179 padList.push_back(pad.second);
1180 }
1181
1182 auto flatBufferDescriptor =
1183 CreateSpaceToBatchNdDescriptor(m_flatBufferBuilder,
1184 m_flatBufferBuilder.CreateVector(spaceToBatchNdDescriptor.m_BlockShape),
1185 m_flatBufferBuilder.CreateVector(padList),
1186 GetFlatBufferDataLayout(spaceToBatchNdDescriptor.m_DataLayout));
1187
1188 auto flatBufferLayer = serializer::CreateSpaceToBatchNdLayer(m_flatBufferBuilder,
1189 flatBufferBaseLayer,
1190 flatBufferDescriptor);
1191
1192 CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_SpaceToBatchNdLayer);
1193}
1194
Aron Virginas-Tar972af152019-06-11 14:14:03 +01001195// Build FlatBuffer for SpaceToDepthLayer
Finn Williamsb454c5c2021-02-09 15:56:23 +00001196void SerializerStrategy::SerializeSpaceToDepthLayer(const armnn::IConnectableLayer* layer,
Aron Virginas-Tar972af152019-06-11 14:14:03 +01001197 const armnn::SpaceToDepthDescriptor& spaceToDepthDescriptor,
1198 const char* name)
1199{
Jan Eilers8eb25602020-03-09 12:13:48 +00001200 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +00001201
Aron Virginas-Taraa067142019-06-11 16:01:44 +01001202 auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_SpaceToDepth);
1203 auto flatBufferDescriptor =
1204 CreateSpaceToDepthDescriptor(m_flatBufferBuilder,
1205 spaceToDepthDescriptor.m_BlockSize,
1206 GetFlatBufferDataLayout(spaceToDepthDescriptor.m_DataLayout));
1207
1208 auto flatBufferLayer = serializer::CreateSpaceToDepthLayer(m_flatBufferBuilder,
1209 flatBufferBaseLayer,
1210 flatBufferDescriptor);
1211
1212 CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_SpaceToDepthLayer);
Aron Virginas-Tar972af152019-06-11 14:14:03 +01001213}
1214
Jim Flynn18ce3382019-03-08 11:08:30 +00001215// Build FlatBuffer for Splitter Layer
Finn Williamsb454c5c2021-02-09 15:56:23 +00001216void SerializerStrategy::SerializeSplitterLayer(const armnn::IConnectableLayer* layer,
Jim Flynn18ce3382019-03-08 11:08:30 +00001217 const armnn::ViewsDescriptor& viewsDescriptor,
1218 const char* name)
1219{
Jan Eilers8eb25602020-03-09 12:13:48 +00001220 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +00001221
Jim Flynn18ce3382019-03-08 11:08:30 +00001222 // Create FlatBuffer ViewOrigins
1223 std::vector<flatbuffers::Offset<UintVector>> flatBufferViewOrigins;
1224 flatBufferViewOrigins.reserve(viewsDescriptor.GetNumViews());
1225
1226 for(unsigned int vIdx = 0; vIdx < viewsDescriptor.GetNumViews(); ++vIdx)
1227 {
1228 std::vector<uint32_t> viewOrigin;
1229 viewOrigin.reserve(viewsDescriptor.GetNumDimensions());
1230
1231 // Copy vector
1232 for(unsigned int dIdx = 0; dIdx < viewsDescriptor.GetNumDimensions(); ++dIdx)
1233 {
1234 viewOrigin.push_back(viewsDescriptor.GetViewOrigin(vIdx)[dIdx]);
1235 }
1236
1237 flatBufferViewOrigins.push_back(CreateUintVector(m_flatBufferBuilder,
1238 m_flatBufferBuilder.CreateVector(viewOrigin)));
1239 }
1240
1241 // Create FlatBuffer OriginsDescriptor
1242 auto flatBufferOriginDescriptor = CreateOriginsDescriptor(m_flatBufferBuilder,
1243 viewsDescriptor.GetOrigins().GetConcatAxis(),
1244 viewsDescriptor.GetOrigins().GetNumViews(),
1245 viewsDescriptor.GetOrigins().GetNumDimensions(),
1246 m_flatBufferBuilder.CreateVector(flatBufferViewOrigins));
1247
1248 // Create FlatBuffer ViewOrigins
1249 std::vector<flatbuffers::Offset<UintVector>> flatBufferViewSizes;
1250 flatBufferViewSizes.reserve(viewsDescriptor.GetNumViews());
1251
1252 for(unsigned int vIdx = 0; vIdx < viewsDescriptor.GetNumViews(); ++vIdx)
1253 {
1254 std::vector<uint32_t> viewSize;
1255 viewSize.reserve(viewsDescriptor.GetNumDimensions());
1256
1257 // Copy vector
1258 for(unsigned int dIdx = 0; dIdx < viewsDescriptor.GetNumDimensions(); ++dIdx)
1259 {
1260 viewSize.push_back(viewsDescriptor.GetViewSizes(vIdx)[dIdx]);
1261 }
1262
1263 flatBufferViewSizes.push_back(CreateUintVector(m_flatBufferBuilder,
1264 m_flatBufferBuilder.CreateVector(viewSize)));
1265 }
1266
1267 // Create FlatBuffer ViewsDescriptor
1268 auto flatBufferViewsDescriptor = CreateViewsDescriptor(m_flatBufferBuilder,
1269 flatBufferOriginDescriptor,
1270 m_flatBufferBuilder.CreateVector(flatBufferViewSizes));
1271
1272 // Create FlatBuffer BaseLayer
1273 auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Splitter);
1274
1275 auto flatBufferSplitterLayer = serializer::CreateSplitterLayer(m_flatBufferBuilder,
1276 flatBufferBaseLayer,
1277 flatBufferViewsDescriptor);
1278
1279 CreateAnyLayer(flatBufferSplitterLayer.o, serializer::Layer::Layer_SplitterLayer);
1280}
1281
Finn Williamsb454c5c2021-02-09 15:56:23 +00001282void SerializerStrategy::SerializeNormalizationLayer(const armnn::IConnectableLayer* layer,
Nina Drozd57728782019-02-27 10:53:27 +00001283 const armnn::NormalizationDescriptor& descriptor,
1284 const char* name)
1285{
Jan Eilers8eb25602020-03-09 12:13:48 +00001286 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +00001287
Nina Drozd57728782019-02-27 10:53:27 +00001288 auto fbNormalizationBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Normalization);
1289
1290 auto fbNormalizationDescriptor = serializer::CreateNormalizationDescriptor(
1291 m_flatBufferBuilder,
1292 GetFlatBufferNormalizationAlgorithmChannel(descriptor.m_NormChannelType),
1293 GetFlatBufferNormalizationAlgorithmMethod(descriptor.m_NormMethodType),
1294 descriptor.m_NormSize,
1295 descriptor.m_Alpha,
1296 descriptor.m_Beta,
1297 descriptor.m_K,
1298 GetFlatBufferDataLayout(descriptor.m_DataLayout));
1299
1300 auto flatBufferLayer = serializer::CreateNormalizationLayer(m_flatBufferBuilder,
1301 fbNormalizationBaseLayer,
1302 fbNormalizationDescriptor);
1303
1304 CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_NormalizationLayer);
1305}
1306
Keith Davis3ae3f972021-05-21 16:33:48 +01001307void SerializerStrategy::SerializeShapeLayer(const armnn::IConnectableLayer* layer,
1308 const char* name)
1309{
1310 IgnoreUnused(name);
1311
1312 auto shapeBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Shape);
1313 auto shapeLayer = serializer::CreateShapeLayer(m_flatBufferBuilder, shapeBaseLayer);
1314
1315 CreateAnyLayer(shapeLayer.o, serializer::Layer::Layer_ShapeLayer);
1316}
1317
Finn Williamsb454c5c2021-02-09 15:56:23 +00001318void SerializerStrategy::SerializeStackLayer(const armnn::IConnectableLayer* layer,
Matthew Jackson2b8c1da2019-07-04 14:59:16 +01001319 const armnn::StackDescriptor& stackDescriptor,
1320 const char* name)
1321{
Jan Eilers8eb25602020-03-09 12:13:48 +00001322 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +00001323
Matthew Jacksonb5433ee2019-07-11 15:54:20 +01001324 auto stackBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Stack);
1325
1326 std::vector<unsigned int> inputShape;
1327 for (unsigned int i =0; i < stackDescriptor.m_InputShape.GetNumDimensions(); i++)
1328 {
1329 inputShape.push_back(stackDescriptor.m_InputShape[i]);
1330 }
1331
1332 auto flatBufferStackDescriptor = CreateStackDescriptor(m_flatBufferBuilder,
1333 stackDescriptor.m_Axis,
1334 stackDescriptor.m_NumInputs,
1335 m_flatBufferBuilder.CreateVector(inputShape));
1336
1337 auto stackLayer = serializer::CreateStackLayer(m_flatBufferBuilder, stackBaseLayer, flatBufferStackDescriptor);
1338 CreateAnyLayer(stackLayer.o, serializer::Layer::Layer_StackLayer);
Matthew Jackson2b8c1da2019-07-04 14:59:16 +01001339}
1340
Finn Williamsb454c5c2021-02-09 15:56:23 +00001341void SerializerStrategy::SerializeStandInLayer(const armnn::IConnectableLayer *layer,
Derek Lamberti013c3902019-10-21 10:46:16 +01001342 const armnn::StandInDescriptor& standInDescriptor,
1343 const char *name)
1344{
Jan Eilers8eb25602020-03-09 12:13:48 +00001345 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +00001346
Aron Virginas-Tar85121a22019-10-23 10:41:35 +01001347 auto fbDescriptor = serializer::CreateStandInDescriptor(m_flatBufferBuilder,
1348 standInDescriptor.m_NumInputs,
1349 standInDescriptor.m_NumOutputs);
1350
1351 auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_StandIn);
1352 auto fbLayer = serializer::CreateStandInLayer(m_flatBufferBuilder, fbBaseLayer, fbDescriptor);
1353
1354 CreateAnyLayer(fbLayer.o, serializer::Layer::Layer_StandInLayer);
Derek Lamberti013c3902019-10-21 10:46:16 +01001355}
1356
Finn Williamsb454c5c2021-02-09 15:56:23 +00001357void SerializerStrategy::SerializeStridedSliceLayer(const armnn::IConnectableLayer* layer,
Nattapat Chaimanowongb3485212019-03-04 12:35:39 +00001358 const armnn::StridedSliceDescriptor& stridedSliceDescriptor,
1359 const char* name)
1360{
Jan Eilers8eb25602020-03-09 12:13:48 +00001361 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +00001362
Nattapat Chaimanowongb3485212019-03-04 12:35:39 +00001363 auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_StridedSlice);
1364
1365 auto flatBufferDescriptor =
1366 CreateStridedSliceDescriptor(m_flatBufferBuilder,
1367 m_flatBufferBuilder.CreateVector(stridedSliceDescriptor.m_Begin),
1368 m_flatBufferBuilder.CreateVector(stridedSliceDescriptor.m_End),
1369 m_flatBufferBuilder.CreateVector(stridedSliceDescriptor.m_Stride),
1370 stridedSliceDescriptor.m_BeginMask,
1371 stridedSliceDescriptor.m_EndMask,
1372 stridedSliceDescriptor.m_ShrinkAxisMask,
1373 stridedSliceDescriptor.m_EllipsisMask,
1374 stridedSliceDescriptor.m_NewAxisMask,
1375 GetFlatBufferDataLayout(stridedSliceDescriptor.m_DataLayout));
1376
1377 auto flatBufferLayer = serializer::CreateStridedSliceLayer(m_flatBufferBuilder,
1378 flatBufferBaseLayer,
1379 flatBufferDescriptor);
1380
1381 CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_StridedSliceLayer);
1382}
1383
Finn Williamsb454c5c2021-02-09 15:56:23 +00001384void SerializerStrategy::SerializeSubtractionLayer(const armnn::IConnectableLayer* layer, const char* name)
Conor Kennedyda1f9752019-03-01 14:37:12 +00001385{
Jan Eilers8eb25602020-03-09 12:13:48 +00001386 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +00001387
Conor Kennedyda1f9752019-03-01 14:37:12 +00001388 auto fbSubtractionBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Subtraction);
1389 auto fbSubtractionLayer = serializer::CreateSubtractionLayer(m_flatBufferBuilder, fbSubtractionBaseLayer);
1390
1391 CreateAnyLayer(fbSubtractionLayer.o, serializer::Layer::Layer_SubtractionLayer);
1392}
1393
Finn Williamsb454c5c2021-02-09 15:56:23 +00001394void SerializerStrategy::SerializeSwitchLayer(const armnn::IConnectableLayer* layer, const char* name)
Sadik Armaganeff363d2019-04-05 15:25:46 +01001395{
Jan Eilers8eb25602020-03-09 12:13:48 +00001396 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +00001397
Sadik Armaganeff363d2019-04-05 15:25:46 +01001398 auto fbSwitchBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Switch);
1399 auto fbSwitchLayer = serializer::CreateSwitchLayer(m_flatBufferBuilder, fbSwitchBaseLayer);
1400
1401 CreateAnyLayer(fbSwitchLayer.o, serializer::Layer::Layer_SwitchLayer);
1402}
1403
Finn Williamsb454c5c2021-02-09 15:56:23 +00001404void SerializerStrategy::SerializeTransposeConvolution2dLayer(
Aron Virginas-Tar639fb042019-06-20 14:28:19 +01001405 const armnn::IConnectableLayer* layer,
1406 const armnn::TransposeConvolution2dDescriptor& descriptor,
Finn Williamsb454c5c2021-02-09 15:56:23 +00001407 const std::vector<armnn::ConstTensor>& constants,
Aron Virginas-Tar639fb042019-06-20 14:28:19 +01001408 const char* name)
1409{
Jan Eilers8eb25602020-03-09 12:13:48 +00001410 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +00001411
Finn Williamsb454c5c2021-02-09 15:56:23 +00001412 const armnn::ConstTensor& weights = constants.at(0);
1413
Aron Virginas-Tarcb549302019-06-21 13:53:38 +01001414 auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Convolution2d);
1415 auto fbDescriptor = CreateTransposeConvolution2dDescriptor(m_flatBufferBuilder,
1416 descriptor.m_PadLeft,
1417 descriptor.m_PadRight,
1418 descriptor.m_PadTop,
1419 descriptor.m_PadBottom,
1420 descriptor.m_StrideX,
1421 descriptor.m_StrideY,
1422 descriptor.m_BiasEnabled,
1423 GetFlatBufferDataLayout(descriptor.m_DataLayout));
1424
1425 // weights & biases
1426 auto fbWeightsConstTensorInfo = CreateConstTensorInfo(weights);
1427 flatbuffers::Offset<serializer::ConstTensor> fbBiasesConstTensorInfo;
Finn Williamsb454c5c2021-02-09 15:56:23 +00001428 if (constants.size() > 1)
Aron Virginas-Tarcb549302019-06-21 13:53:38 +01001429 {
Finn Williamsb454c5c2021-02-09 15:56:23 +00001430 const armnn::ConstTensor& biases = constants.at(1);
1431 fbBiasesConstTensorInfo = CreateConstTensorInfo(biases);
Aron Virginas-Tarcb549302019-06-21 13:53:38 +01001432 }
1433
1434 auto fbLayer = CreateTransposeConvolution2dLayer(m_flatBufferBuilder,
1435 fbBaseLayer,
1436 fbDescriptor,
1437 fbWeightsConstTensorInfo,
1438 fbBiasesConstTensorInfo);
1439
1440 CreateAnyLayer(fbLayer.o, serializer::Layer::Layer_TransposeConvolution2dLayer);
Aron Virginas-Tar639fb042019-06-20 14:28:19 +01001441}
1442
Finn Williamsb454c5c2021-02-09 15:56:23 +00001443void SerializerStrategy::SerializeTransposeLayer(const armnn::IConnectableLayer* layer,
Mike Kellyc9ea45a2020-02-28 18:11:58 +00001444 const armnn::TransposeDescriptor& descriptor,
1445 const char* name)
1446{
Jan Eilers8eb25602020-03-09 12:13:48 +00001447 IgnoreUnused(name);
Mike Kellyc9ea45a2020-02-28 18:11:58 +00001448
1449 // Create FlatBuffer BaseLayer
1450 auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Transpose);
1451
1452 std::vector<unsigned int> dimMappings;
1453 for (unsigned int i=0; i<descriptor.m_DimMappings.GetSize(); ++i)
1454 {
1455 dimMappings.push_back(descriptor.m_DimMappings[i]);
1456 }
1457
1458 auto flatBufferDesc = serializer::CreateTransposeDescriptor(m_flatBufferBuilder,
1459 m_flatBufferBuilder.CreateVector(dimMappings));
1460
1461 // Create the FlatBuffer TransposeLayer
1462 auto flatBufferLayer = serializer::CreateTransposeLayer(m_flatBufferBuilder,
1463 flatBufferBaseLayer,
1464 flatBufferDesc);
1465
1466 // Add the AnyLayer to the FlatBufferLayers
1467 CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_TransposeLayer);
1468}
1469
Finn Williamsb454c5c2021-02-09 15:56:23 +00001470void SerializerStrategy::SerializeQLstmLayer(const armnn::IConnectableLayer* layer,
1471 const armnn::QLstmDescriptor& descriptor,
1472 const std::vector<armnn::ConstTensor>& constants,
1473 const char* name)
James Conroy586a9aa2020-03-20 08:49:33 +00001474{
James Conroy8d333182020-05-13 10:27:58 +01001475 IgnoreUnused(name);
James Conroy586a9aa2020-03-20 08:49:33 +00001476
James Conroy8d333182020-05-13 10:27:58 +01001477 auto fbQLstmBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_QLstm);
1478
1479 auto fbQLstmDescriptor = serializer::CreateQLstmDescriptor(
1480 m_flatBufferBuilder,
1481 descriptor.m_CifgEnabled,
1482 descriptor.m_PeepholeEnabled,
1483 descriptor.m_ProjectionEnabled,
1484 descriptor.m_LayerNormEnabled,
1485 descriptor.m_CellClip,
1486 descriptor.m_ProjectionClip,
1487 descriptor.m_InputIntermediateScale,
1488 descriptor.m_ForgetIntermediateScale,
1489 descriptor.m_CellIntermediateScale,
1490 descriptor.m_OutputIntermediateScale,
1491 descriptor.m_HiddenStateZeroPoint,
1492 descriptor.m_HiddenStateScale
1493 );
1494
Finn Williamsb454c5c2021-02-09 15:56:23 +00001495 // Index for constants vector
1496 std::size_t i = 0;
1497
James Conroy8d333182020-05-13 10:27:58 +01001498 // Mandatory params
Finn Williamsb454c5c2021-02-09 15:56:23 +00001499 auto inputToForgetWeights = CreateConstTensorInfo(constants[i++]); //InputToForgetWeights
1500 auto inputToCellWeights = CreateConstTensorInfo(constants[i++]); //InputToCellWeights
1501 auto inputToOutputWeights = CreateConstTensorInfo(constants[i++]); //InputToOutputWeights
1502 auto recurrentToForgetWeights = CreateConstTensorInfo(constants[i++]); //RecurrentToForgetWeights
1503 auto recurrentToCellWeights = CreateConstTensorInfo(constants[i++]); //RecurrentToCellWeights
1504 auto recurrentToOutputWeights = CreateConstTensorInfo(constants[i++]); //RecurrentToOutputWeights
1505 auto forgetGateBias = CreateConstTensorInfo(constants[i++]); //ForgetGateBias
1506 auto cellBias = CreateConstTensorInfo(constants[i++]); //CellBias
1507 auto outputGateBias = CreateConstTensorInfo(constants[i++]); //OutputGateBias
James Conroy8d333182020-05-13 10:27:58 +01001508
1509 // CIFG
1510 flatbuffers::Offset<serializer::ConstTensor> inputToInputWeights;
1511 flatbuffers::Offset<serializer::ConstTensor> recurrentToInputWeights;
1512 flatbuffers::Offset<serializer::ConstTensor> inputGateBias;
1513
1514 if (!descriptor.m_CifgEnabled)
1515 {
Finn Williamsb454c5c2021-02-09 15:56:23 +00001516 inputToInputWeights = CreateConstTensorInfo(constants[i++]); //InputToInputWeights
1517 recurrentToInputWeights = CreateConstTensorInfo(constants[i++]); //RecurrentToInputWeights
1518 inputGateBias = CreateConstTensorInfo(constants[i++]); //InputGateBias
James Conroy8d333182020-05-13 10:27:58 +01001519 }
1520
1521 // Peephole
1522 flatbuffers::Offset<serializer::ConstTensor> cellToInputWeights;
1523 flatbuffers::Offset<serializer::ConstTensor> cellToForgetWeights;
1524 flatbuffers::Offset<serializer::ConstTensor> cellToOutputWeights;
1525
1526 if (descriptor.m_PeepholeEnabled)
1527 {
1528 if (!descriptor.m_CifgEnabled)
1529 {
Finn Williamsb454c5c2021-02-09 15:56:23 +00001530 cellToInputWeights = CreateConstTensorInfo(constants[i++]); //CellToInputWeights
James Conroy8d333182020-05-13 10:27:58 +01001531 }
Finn Williamsb454c5c2021-02-09 15:56:23 +00001532 cellToForgetWeights = CreateConstTensorInfo(constants[i++]); //CellToForgetWeights
1533 cellToOutputWeights = CreateConstTensorInfo(constants[i++]); //CellToOutputWeights
1534 }
James Conroy8d333182020-05-13 10:27:58 +01001535
Finn Williamsb454c5c2021-02-09 15:56:23 +00001536 // Projection
1537 flatbuffers::Offset<serializer::ConstTensor> projectionWeights;
1538 flatbuffers::Offset<serializer::ConstTensor> projectionBias;
1539
1540 if (descriptor.m_ProjectionEnabled)
1541 {
1542 projectionWeights = CreateConstTensorInfo(constants[i++]); //ProjectionWeights
1543 projectionBias = CreateConstTensorInfo(constants[i++]); //ProjectionBias
James Conroy8d333182020-05-13 10:27:58 +01001544 }
1545
1546 // Layer norm
1547 flatbuffers::Offset<serializer::ConstTensor> inputLayerNormWeights;
1548 flatbuffers::Offset<serializer::ConstTensor> forgetLayerNormWeights;
1549 flatbuffers::Offset<serializer::ConstTensor> cellLayerNormWeights;
1550 flatbuffers::Offset<serializer::ConstTensor> outputLayerNormWeights;
1551
1552 if (descriptor.m_LayerNormEnabled)
1553 {
1554 if (!descriptor.m_CifgEnabled)
1555 {
Finn Williamsb454c5c2021-02-09 15:56:23 +00001556 inputLayerNormWeights = CreateConstTensorInfo(constants[i++]); //InputLayerNormWeights
James Conroy8d333182020-05-13 10:27:58 +01001557 }
Finn Williamsb454c5c2021-02-09 15:56:23 +00001558 forgetLayerNormWeights = CreateConstTensorInfo(constants[i++]); //ForgetLayerNormWeights
1559 cellLayerNormWeights = CreateConstTensorInfo(constants[i++]); //CellLayerNormWeights
1560 outputLayerNormWeights = CreateConstTensorInfo(constants[i++]); //OutputLayerNormWeights
James Conroy8d333182020-05-13 10:27:58 +01001561 }
1562
1563 auto fbQLstmParams = serializer::CreateQLstmInputParams(
1564 m_flatBufferBuilder,
1565 inputToForgetWeights,
1566 inputToCellWeights,
1567 inputToOutputWeights,
1568 recurrentToForgetWeights,
1569 recurrentToCellWeights,
1570 recurrentToOutputWeights,
1571 forgetGateBias,
1572 cellBias,
1573 outputGateBias,
1574 inputToInputWeights,
1575 recurrentToInputWeights,
1576 inputGateBias,
1577 projectionWeights,
1578 projectionBias,
1579 cellToInputWeights,
1580 cellToForgetWeights,
1581 cellToOutputWeights,
1582 inputLayerNormWeights,
1583 forgetLayerNormWeights,
1584 cellLayerNormWeights,
1585 outputLayerNormWeights);
1586
1587 auto fbQLstmLayer = serializer::CreateQLstmLayer(
1588 m_flatBufferBuilder,
1589 fbQLstmBaseLayer,
1590 fbQLstmDescriptor,
1591 fbQLstmParams);
1592
1593 CreateAnyLayer(fbQLstmLayer.o, serializer::Layer::Layer_QLstmLayer);
James Conroy586a9aa2020-03-20 08:49:33 +00001594}
1595
Finn Williamsb454c5c2021-02-09 15:56:23 +00001596void SerializerStrategy::SerializeQuantizedLstmLayer(const armnn::IConnectableLayer* layer,
1597 const std::vector<armnn::ConstTensor>& constants,
1598 const char* name)
James Conroyee18dc82019-07-17 11:27:46 +01001599{
Jan Eilers8eb25602020-03-09 12:13:48 +00001600 IgnoreUnused(name);
Derek Lamberti859f9ce2019-12-10 22:05:21 +00001601
Jan Eilers5b01a892019-07-23 09:47:43 +01001602 auto fbQuantizedLstmBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_QuantizedLstm);
1603
Finn Williamsb454c5c2021-02-09 15:56:23 +00001604 // index for constants vector
1605 size_t i = 0;
1606
Jan Eilers5b01a892019-07-23 09:47:43 +01001607 // Get input parameters
Finn Williamsb454c5c2021-02-09 15:56:23 +00001608 auto inputToInputWeights = CreateConstTensorInfo(constants[i++]);
1609 auto inputToForgetWeights = CreateConstTensorInfo(constants[i++]);
1610 auto inputToCellWeights = CreateConstTensorInfo(constants[i++]);
1611 auto inputToOutputWeights = CreateConstTensorInfo(constants[i++]);
Jan Eilers5b01a892019-07-23 09:47:43 +01001612
Finn Williamsb454c5c2021-02-09 15:56:23 +00001613 auto recurrentToInputWeights = CreateConstTensorInfo(constants[i++]);
1614 auto recurrentToForgetWeights = CreateConstTensorInfo(constants[i++]);
1615 auto recurrentToCellWeights = CreateConstTensorInfo(constants[i++]);
1616 auto recurrentToOutputWeights = CreateConstTensorInfo(constants[i++]);
Jan Eilers5b01a892019-07-23 09:47:43 +01001617
Finn Williamsb454c5c2021-02-09 15:56:23 +00001618 auto inputGateBias = CreateConstTensorInfo(constants[i++]);
1619 auto forgetGateBias = CreateConstTensorInfo(constants[i++]);
1620 auto cellBias = CreateConstTensorInfo(constants[i++]);
1621 auto outputGateBias = CreateConstTensorInfo(constants[i++]);
Jan Eilers5b01a892019-07-23 09:47:43 +01001622
1623 auto fbQuantizedLstmParams = serializer::CreateQuantizedLstmInputParams(
1624 m_flatBufferBuilder,
1625 inputToInputWeights,
1626 inputToForgetWeights,
1627 inputToCellWeights,
1628 inputToOutputWeights,
1629 recurrentToInputWeights,
1630 recurrentToForgetWeights,
1631 recurrentToCellWeights,
1632 recurrentToOutputWeights,
1633 inputGateBias,
1634 forgetGateBias,
1635 cellBias,
1636 outputGateBias);
1637
1638 auto fbQuantizedLstmLayer = serializer::CreateQuantizedLstmLayer(
1639 m_flatBufferBuilder,
1640 fbQuantizedLstmBaseLayer,
1641 fbQuantizedLstmParams);
1642
1643 CreateAnyLayer(fbQuantizedLstmLayer.o, serializer::Layer::Layer_QuantizedLstmLayer);
James Conroyee18dc82019-07-17 11:27:46 +01001644}
1645
Narumol Prangnawarata0162e12021-07-23 14:47:49 +01001646void SerializerStrategy::SerializeUnidirectionalSequenceLstmLayer(
1647 const armnn::IConnectableLayer* layer,
1648 const armnn::UnidirectionalSequenceLstmDescriptor& descriptor,
1649 const std::vector<armnn::ConstTensor>& constants,
1650 const char* name)
1651{
1652 IgnoreUnused(name);
1653
1654 auto fbUnidirectionalSequenceLstmBaseLayer =
1655 CreateLayerBase(layer, serializer::LayerType::LayerType_UnidirectionalSequenceLstm);
1656
1657 auto fbUnidirectionalSequenceLstmDescriptor = serializer::CreateUnidirectionalSequenceLstmDescriptor(
1658 m_flatBufferBuilder,
1659 descriptor.m_ActivationFunc,
1660 descriptor.m_ClippingThresCell,
1661 descriptor.m_ClippingThresProj,
1662 descriptor.m_CifgEnabled,
1663 descriptor.m_PeepholeEnabled,
1664 descriptor.m_ProjectionEnabled,
1665 descriptor.m_LayerNormEnabled,
1666 descriptor.m_TimeMajor);
1667
1668 // Index for constants vector
1669 std::size_t i = 0;
1670
1671 // Get mandatory/basic input parameters
1672 auto inputToForgetWeights = CreateConstTensorInfo(constants[i++]); //InputToForgetWeights
1673 auto inputToCellWeights = CreateConstTensorInfo(constants[i++]); //InputToCellWeights
1674 auto inputToOutputWeights = CreateConstTensorInfo(constants[i++]); //InputToOutputWeights
1675 auto recurrentToForgetWeights = CreateConstTensorInfo(constants[i++]); //RecurrentToForgetWeights
1676 auto recurrentToCellWeights = CreateConstTensorInfo(constants[i++]); //RecurrentToCellWeights
1677 auto recurrentToOutputWeights = CreateConstTensorInfo(constants[i++]); //RecurrentToOutputWeights
1678 auto forgetGateBias = CreateConstTensorInfo(constants[i++]); //ForgetGateBias
1679 auto cellBias = CreateConstTensorInfo(constants[i++]); //CellBias
1680 auto outputGateBias = CreateConstTensorInfo(constants[i++]); //OutputGateBias
1681
1682 //Define optional parameters, these will be set depending on configuration in Lstm descriptor
1683 flatbuffers::Offset<serializer::ConstTensor> inputToInputWeights;
1684 flatbuffers::Offset<serializer::ConstTensor> recurrentToInputWeights;
1685 flatbuffers::Offset<serializer::ConstTensor> cellToInputWeights;
1686 flatbuffers::Offset<serializer::ConstTensor> inputGateBias;
1687 flatbuffers::Offset<serializer::ConstTensor> projectionWeights;
1688 flatbuffers::Offset<serializer::ConstTensor> projectionBias;
1689 flatbuffers::Offset<serializer::ConstTensor> cellToForgetWeights;
1690 flatbuffers::Offset<serializer::ConstTensor> cellToOutputWeights;
1691 flatbuffers::Offset<serializer::ConstTensor> inputLayerNormWeights;
1692 flatbuffers::Offset<serializer::ConstTensor> forgetLayerNormWeights;
1693 flatbuffers::Offset<serializer::ConstTensor> cellLayerNormWeights;
1694 flatbuffers::Offset<serializer::ConstTensor> outputLayerNormWeights;
1695
1696 if (!descriptor.m_CifgEnabled)
1697 {
1698 inputToInputWeights = CreateConstTensorInfo(constants[i++]); //InputToInputWeights
1699 recurrentToInputWeights = CreateConstTensorInfo(constants[i++]); //RecurrentToInputWeights
1700 inputGateBias = CreateConstTensorInfo(constants[i++]); //InputGateBias
1701 }
1702
1703 if (descriptor.m_PeepholeEnabled)
1704 {
1705 if (!descriptor.m_CifgEnabled)
1706 {
1707 cellToInputWeights = CreateConstTensorInfo(constants[i++]); //CellToInputWeights
1708 }
1709 cellToForgetWeights = CreateConstTensorInfo(constants[i++]); //CellToForgetWeights
1710 cellToOutputWeights = CreateConstTensorInfo(constants[i++]); //CellToOutputWeights
1711 }
1712
1713 if (descriptor.m_ProjectionEnabled)
1714 {
1715 projectionWeights = CreateConstTensorInfo(constants[i++]); //ProjectionWeights
1716 projectionBias = CreateConstTensorInfo(constants[i++]); //ProjectionBias
1717 }
1718
1719 if (descriptor.m_LayerNormEnabled)
1720 {
1721 if (!descriptor.m_CifgEnabled)
1722 {
1723 inputLayerNormWeights = CreateConstTensorInfo(constants[i++]); //InputLayerNormWeights
1724 }
1725 forgetLayerNormWeights = CreateConstTensorInfo(constants[i++]); //ForgetLayerNormWeights
1726 cellLayerNormWeights = CreateConstTensorInfo(constants[i++]); //CellLayerNormWeights
1727 outputLayerNormWeights = CreateConstTensorInfo(constants[i++]); //OutputLayerNormWeights
1728 }
1729
1730 auto fbUnidirectionalSequenceLstmParams = serializer::CreateLstmInputParams(
1731 m_flatBufferBuilder,
1732 inputToForgetWeights,
1733 inputToCellWeights,
1734 inputToOutputWeights,
1735 recurrentToForgetWeights,
1736 recurrentToCellWeights,
1737 recurrentToOutputWeights,
1738 forgetGateBias,
1739 cellBias,
1740 outputGateBias,
1741 inputToInputWeights,
1742 recurrentToInputWeights,
1743 cellToInputWeights,
1744 inputGateBias,
1745 projectionWeights,
1746 projectionBias,
1747 cellToForgetWeights,
1748 cellToOutputWeights,
1749 inputLayerNormWeights,
1750 forgetLayerNormWeights,
1751 cellLayerNormWeights,
1752 outputLayerNormWeights);
1753
1754 auto fbUnidirectionalSequenceLstmLayer = serializer::CreateUnidirectionalSequenceLstmLayer(
1755 m_flatBufferBuilder,
1756 fbUnidirectionalSequenceLstmBaseLayer,
1757 fbUnidirectionalSequenceLstmDescriptor,
1758 fbUnidirectionalSequenceLstmParams);
1759
1760 CreateAnyLayer(fbUnidirectionalSequenceLstmLayer.o, serializer::Layer::Layer_UnidirectionalSequenceLstmLayer);
1761}
1762
Finn Williamsb454c5c2021-02-09 15:56:23 +00001763fb::Offset<serializer::LayerBase> SerializerStrategy::CreateLayerBase(const IConnectableLayer* layer,
Nattapat Chaimanowongac9cadc2019-02-13 15:52:41 +00001764 const serializer::LayerType layerType)
Mike Kelly8c1701a2019-02-11 17:01:27 +00001765{
Derek Lamberti859f9ce2019-12-10 22:05:21 +00001766
Sadik Armagandb059fd2019-03-20 12:28:32 +00001767 uint32_t fbIndex = GetSerializedId(layer->GetGuid());
1768
Mike Kelly8c1701a2019-02-11 17:01:27 +00001769 std::vector<fb::Offset<serializer::InputSlot>> inputSlots = CreateInputSlots(layer);
1770 std::vector<fb::Offset<serializer::OutputSlot>> outputSlots = CreateOutputSlots(layer);
1771
1772 return serializer::CreateLayerBase(m_flatBufferBuilder,
Sadik Armagandb059fd2019-03-20 12:28:32 +00001773 fbIndex,
Mike Kelly8c1701a2019-02-11 17:01:27 +00001774 m_flatBufferBuilder.CreateString(layer->GetName()),
1775 layerType,
1776 m_flatBufferBuilder.CreateVector(inputSlots),
1777 m_flatBufferBuilder.CreateVector(outputSlots));
1778}
1779
Finn Williamsb454c5c2021-02-09 15:56:23 +00001780void SerializerStrategy::CreateAnyLayer(const flatbuffers::Offset<void>& layer, const serializer::Layer serializerLayer)
Mike Kelly8c1701a2019-02-11 17:01:27 +00001781{
Derek Lamberti859f9ce2019-12-10 22:05:21 +00001782
Derek Lamberti0028d1b2019-02-20 13:57:42 +00001783 auto anyLayer = armnnSerializer::CreateAnyLayer(m_flatBufferBuilder, serializerLayer, layer);
Mike Kelly8c1701a2019-02-11 17:01:27 +00001784 m_serializedLayers.push_back(anyLayer);
1785}
1786
Mike Kellya0766c32019-02-19 17:22:07 +00001787template <typename T>
Finn Williamsb454c5c2021-02-09 15:56:23 +00001788flatbuffers::Offset<flatbuffers::Vector<T>> SerializerStrategy::CreateDataVector(const void* memory, unsigned int size)
Mike Kellya0766c32019-02-19 17:22:07 +00001789{
1790 const T* buffer = reinterpret_cast<const T*>(memory);
1791 std::vector<T> vector(buffer, buffer + (size / sizeof(T)));
1792 auto fbVector = m_flatBufferBuilder.CreateVector(vector);
1793 return fbVector;
1794}
1795
Finn Williamsb454c5c2021-02-09 15:56:23 +00001796flatbuffers::Offset<TensorInfo> SerializerStrategy::CreateTensorInfo(const armnn::TensorInfo& tensorInfo)
Mike Kellya0766c32019-02-19 17:22:07 +00001797{
Mike Kellya0766c32019-02-19 17:22:07 +00001798 // Get the dimensions
1799 std::vector<unsigned int> shape;
Colm Donelan800b2812021-02-12 12:43:35 +00001800 std::vector<bool> specificity;
1801 // This assumes that the TensorShape constructors have ensured that the size of m_DimensionsSpecificity
1802 // matches the size of dimensions.
1803 for(unsigned int dim = 0; dim < tensorInfo.GetShape().GetNumDimensions(); ++dim)
1804 {
1805 specificity.push_back(tensorInfo.GetShape().GetDimensionSpecificity(dim));
Mike Kellydf258592021-04-26 23:53:31 +01001806
1807 if (tensorInfo.GetShape().GetDimensionSpecificity(dim))
1808 {
1809 shape.push_back(tensorInfo.GetShape()[dim]);
1810 }
1811 else
1812 {
1813 shape.push_back(0);
1814 }
Colm Donelan800b2812021-02-12 12:43:35 +00001815 }
1816
Sadik Armagan1a84fe32020-03-27 15:56:57 +00001817 if (tensorInfo.HasPerAxisQuantization())
1818 {
1819 // Create FlatBuffer TensorInfo
1820 auto flatBufferTensorInfo =
1821 serializer::CreateTensorInfo(m_flatBufferBuilder,
1822 m_flatBufferBuilder.CreateVector(shape),
1823 GetFlatBufferDataType(tensorInfo.GetDataType()),
1824 tensorInfo.GetQuantizationScales()[0],
1825 tensorInfo.GetQuantizationOffset(),
1826 m_flatBufferBuilder.CreateVector(tensorInfo.GetQuantizationScales()),
Finn Williams2605b232020-06-10 15:53:46 +01001827 tensorInfo.GetQuantizationDim().value(),
1828 static_cast<unsigned int>
Colm Donelan800b2812021-02-12 12:43:35 +00001829 (tensorInfo.GetShape().GetDimensionality()),
1830 m_flatBufferBuilder.CreateVector(specificity));
Sadik Armagan1a84fe32020-03-27 15:56:57 +00001831 return flatBufferTensorInfo;
1832 }
1833
Mike Kellya0766c32019-02-19 17:22:07 +00001834 // Create FlatBuffer TensorInfo
1835 auto flatBufferTensorInfo = serializer::CreateTensorInfo(m_flatBufferBuilder,
1836 m_flatBufferBuilder.CreateVector(shape),
1837 GetFlatBufferDataType(tensorInfo.GetDataType()),
1838 tensorInfo.GetQuantizationScale(),
Finn Williams2605b232020-06-10 15:53:46 +01001839 tensorInfo.GetQuantizationOffset(),
1840 0,
1841 0,
1842 static_cast<unsigned int>
Colm Donelan800b2812021-02-12 12:43:35 +00001843 (tensorInfo.GetShape().GetDimensionality()),
1844 m_flatBufferBuilder.CreateVector(specificity));
Sadik Armagan1a84fe32020-03-27 15:56:57 +00001845 return flatBufferTensorInfo;
1846}
1847
1848flatbuffers::Offset<serializer::ConstTensor>
Finn Williamsb454c5c2021-02-09 15:56:23 +00001849 SerializerStrategy::CreateConstTensorInfo(const armnn::ConstTensor& constTensor)
Sadik Armagan1a84fe32020-03-27 15:56:57 +00001850{
1851 armnn::TensorInfo tensorInfo = constTensor.GetInfo();
1852
Mike Kellya0766c32019-02-19 17:22:07 +00001853 flatbuffers::Offset<void> fbPayload;
1854
1855 switch (tensorInfo.GetDataType())
1856 {
Mike Kelly1f140f72021-04-06 12:25:55 +01001857 case armnn::DataType::Signed64:
1858 {
1859 auto fbVector = CreateDataVector<int64_t>(constTensor.GetMemoryArea(), constTensor.GetNumBytes());
1860 flatbuffers::Offset<serializer::LongData> flatBuffersData = serializer::CreateLongData(
1861 m_flatBufferBuilder,
1862 fbVector);
1863 fbPayload = flatBuffersData.o;
1864 break;
1865 }
Derek Lamberti0028d1b2019-02-20 13:57:42 +00001866 case armnn::DataType::Float32:
1867 case armnn::DataType::Signed32:
Mike Kellya0766c32019-02-19 17:22:07 +00001868 {
1869 auto fbVector = CreateDataVector<int32_t>(constTensor.GetMemoryArea(), constTensor.GetNumBytes());
1870 flatbuffers::Offset<serializer::IntData> flatBuffersData = serializer::CreateIntData(
1871 m_flatBufferBuilder,
1872 fbVector);
1873 fbPayload = flatBuffersData.o;
1874 break;
1875 }
Derek Lamberti0028d1b2019-02-20 13:57:42 +00001876 case armnn::DataType::Float16:
Mike Kellyae42f012020-04-24 15:44:01 +01001877 case armnn::DataType::BFloat16:
Derek Lambertif90c56d2020-01-10 17:14:08 +00001878 case armnn::DataType::QSymmS16:
Nattapat Chaimanowongcd5ac232019-03-19 12:26:36 +00001879 {
1880 auto fbVector = CreateDataVector<int16_t>(constTensor.GetMemoryArea(), constTensor.GetNumBytes());
1881 flatbuffers::Offset<serializer::ShortData> flatBuffersData = serializer::CreateShortData(
1882 m_flatBufferBuilder,
1883 fbVector);
1884 fbPayload = flatBuffersData.o;
1885 break;
1886 }
Sadik Armagan1a84fe32020-03-27 15:56:57 +00001887 case armnn::DataType::QSymmS8:
Mike Kellyae42f012020-04-24 15:44:01 +01001888 case armnn::DataType::QAsymmS8:
Derek Lambertif90c56d2020-01-10 17:14:08 +00001889 case armnn::DataType::QAsymmU8:
Derek Lamberti0028d1b2019-02-20 13:57:42 +00001890 case armnn::DataType::Boolean:
Mike Kellya0766c32019-02-19 17:22:07 +00001891 default:
1892 {
1893 auto fbVector = CreateDataVector<int8_t>(constTensor.GetMemoryArea(), constTensor.GetNumBytes());
1894 flatbuffers::Offset<serializer::ByteData> flatBuffersData = serializer::CreateByteData(
1895 m_flatBufferBuilder,
1896 fbVector);
1897 fbPayload = flatBuffersData.o;
1898 }
1899 }
1900 flatbuffers::Offset<serializer::ConstTensor> flatBufferConstTensor = serializer::CreateConstTensor(
1901 m_flatBufferBuilder,
Sadik Armagan1a84fe32020-03-27 15:56:57 +00001902 CreateTensorInfo(tensorInfo),
Mike Kellya0766c32019-02-19 17:22:07 +00001903 GetFlatBufferConstTensorData(tensorInfo.GetDataType()),
1904 fbPayload);
1905 return flatBufferConstTensor;
1906}
1907
Finn Williamsb454c5c2021-02-09 15:56:23 +00001908flatbuffers::Offset<armnnSerializer::FeatureCompatibilityVersions> SerializerStrategy::GetVersionTable()
Tee Jungaa920c52019-11-05 10:48:25 +00001909{
1910 flatbuffers::Offset<armnnSerializer::FeatureCompatibilityVersions> versionsTable =
1911 serializer::CreateFeatureCompatibilityVersions(
1912 m_flatBufferBuilder,
Jan Eilers53ef7952021-06-02 12:01:25 +01001913 1, // Binding ids scheme version
Matthew Sloyan81beae32021-07-13 19:46:11 +01001914 1, // Weights layout scheme version
1915 1 // Constant tensors as inputs version
Tee Jungaa920c52019-11-05 10:48:25 +00001916 );
1917 return versionsTable;
1918}
1919
Derek Lamberti0028d1b2019-02-20 13:57:42 +00001920std::vector<fb::Offset<serializer::InputSlot>>
Finn Williamsb454c5c2021-02-09 15:56:23 +00001921 SerializerStrategy::CreateInputSlots(const armnn::IConnectableLayer* layer)
Mike Kelly8c1701a2019-02-11 17:01:27 +00001922{
Mike Kellya0766c32019-02-19 17:22:07 +00001923 std::vector<fb::Offset<serializer::InputSlot>> inputSlots;
Mike Kelly8c1701a2019-02-11 17:01:27 +00001924
1925 // Get the InputSlots
1926 for (unsigned int slotIndex = 0; slotIndex<layer->GetNumInputSlots(); ++slotIndex)
1927 {
1928 const IInputSlot& inputSlot = layer->GetInputSlot(slotIndex);
1929
1930 // Get the Connection for the InputSlot
1931 const IOutputSlot* connection = inputSlot.GetConnection();
1932
1933 // Create FlatBuffer Connection
Saoirse Stewartcb8a3212019-02-14 15:46:10 +00001934 serializer::Connection conn(GetSerializedId(inputSlot.GetConnection()->GetOwningLayerGuid()),
1935 connection->CalculateIndexOnOwner());
Mike Kelly8c1701a2019-02-11 17:01:27 +00001936 // Create FlatBuffer InputSlot
1937 inputSlots.push_back(serializer::CreateInputSlot(m_flatBufferBuilder, slotIndex, &conn));
1938 }
1939 return inputSlots;
1940}
1941
Derek Lamberti0028d1b2019-02-20 13:57:42 +00001942std::vector<fb::Offset<serializer::OutputSlot>>
Finn Williamsb454c5c2021-02-09 15:56:23 +00001943 SerializerStrategy::CreateOutputSlots(const armnn::IConnectableLayer* layer)
Mike Kelly8c1701a2019-02-11 17:01:27 +00001944{
1945 std::vector<fb::Offset<serializer::OutputSlot>> outputSlots;
1946
1947 // Get the OutputSlots
1948 for (unsigned int slotIndex = 0; slotIndex < layer->GetNumOutputSlots(); ++slotIndex)
1949 {
1950 const IOutputSlot& outputSlot = layer->GetOutputSlot(slotIndex);
Derek Lamberti0028d1b2019-02-20 13:57:42 +00001951 const armnn::TensorInfo& tensorInfo = outputSlot.GetTensorInfo();
Mike Kelly8c1701a2019-02-11 17:01:27 +00001952
Mike Kelly8c1701a2019-02-11 17:01:27 +00001953 // Create FlatBuffer Outputslot
1954 outputSlots.push_back(serializer::CreateOutputSlot(m_flatBufferBuilder,
1955 slotIndex,
Sadik Armagan1a84fe32020-03-27 15:56:57 +00001956 CreateTensorInfo(tensorInfo)));
Mike Kelly8c1701a2019-02-11 17:01:27 +00001957 }
1958 return outputSlots;
1959}
1960
Finn Williamsb454c5c2021-02-09 15:56:23 +00001961void SerializerStrategy::ExecuteStrategy(const armnn::IConnectableLayer* layer,
1962 const BaseDescriptor& descriptor,
1963 const std::vector<armnn::ConstTensor>& constants,
1964 const char* name,
1965 const armnn::LayerBindingId id)
1966{
1967 IgnoreUnused(constants);
1968
1969 switch (layer->GetType())
1970 {
1971 case armnn::LayerType::Activation :
1972 {
1973 const armnn::ActivationDescriptor& layerDescriptor =
1974 static_cast<const armnn::ActivationDescriptor&>(descriptor);
1975 SerializeActivationLayer(layer, layerDescriptor, name);
1976 break;
1977 }
1978 case armnn::LayerType::Addition :
1979 {
1980 SerializeAdditionLayer(layer, name);
1981 break;
1982 }
1983 case armnn::LayerType::ArgMinMax :
1984 {
1985 const armnn::ArgMinMaxDescriptor& layerDescriptor =
1986 static_cast<const armnn::ArgMinMaxDescriptor&>(descriptor);
1987 SerializeArgMinMaxLayer(layer, layerDescriptor, name);
1988 break;
1989 }
1990 case armnn::LayerType::BatchNormalization :
1991 {
1992 const armnn::BatchNormalizationDescriptor& layerDescriptor =
1993 static_cast<const armnn::BatchNormalizationDescriptor&>(descriptor);
1994 SerializeBatchNormalizationLayer(layer,
1995 layerDescriptor,
1996 constants,
1997 name);
1998 break;
1999 }
2000 case armnn::LayerType::BatchToSpaceNd :
2001 {
2002 const armnn::BatchToSpaceNdDescriptor& layerDescriptor =
2003 static_cast<const armnn::BatchToSpaceNdDescriptor&>(descriptor);
2004 SerializeBatchToSpaceNdLayer(layer,
2005 layerDescriptor,
2006 name);
2007 break;
2008 }
mathad01b392e982021-04-07 12:07:30 +01002009 case armnn::LayerType::Cast :
2010 {
2011 SerializeCastLayer(layer, name);
2012 break;
2013 }
Simon Obute51f67772021-09-03 15:50:13 +01002014 case armnn::LayerType::ChannelShuffle :
2015 {
2016 const armnn::ChannelShuffleDescriptor& layerDescriptor =
2017 static_cast<const armnn::ChannelShuffleDescriptor&>(descriptor);
2018 SerializeChannelShuffleLayer(layer,
2019 layerDescriptor,
2020 name);
2021 break;
2022 }
Finn Williamsb454c5c2021-02-09 15:56:23 +00002023 case armnn::LayerType::Comparison :
2024 {
2025 const armnn::ComparisonDescriptor& layerDescriptor =
2026 static_cast<const armnn::ComparisonDescriptor&>(descriptor);
2027 SerializeComparisonLayer(layer,
2028 layerDescriptor,
2029 name);
2030 break;
2031 }
2032 case armnn::LayerType::Concat :
2033 {
2034 const armnn::ConcatDescriptor& layerDescriptor =
2035 static_cast<const armnn::ConcatDescriptor&>(descriptor);
2036 SerializeConcatLayer(layer,
2037 layerDescriptor,
2038 name);
2039 break;
2040 }
2041 case armnn::LayerType::Constant :
2042 {
2043 SerializeConstantLayer(layer,
2044 constants,
2045 name);
2046 break;
2047 }
2048 case armnn::LayerType::Convolution2d :
2049 {
2050 const armnn::Convolution2dDescriptor& layerDescriptor =
2051 static_cast<const armnn::Convolution2dDescriptor&>(descriptor);
2052 SerializeConvolution2dLayer(layer,
2053 layerDescriptor,
2054 constants,
2055 name);
2056 break;
2057 }
Matthew Sloyanb63a3112021-09-08 13:05:51 +01002058 case armnn::LayerType::Convolution3d :
2059 {
2060 const armnn::Convolution3dDescriptor& layerDescriptor =
2061 static_cast<const armnn::Convolution3dDescriptor&>(descriptor);
2062 SerializeConvolution3dLayer(layer,
2063 layerDescriptor,
Matthew Sloyanb63a3112021-09-08 13:05:51 +01002064 name);
2065 break;
2066 }
Finn Williamsb454c5c2021-02-09 15:56:23 +00002067 case armnn::LayerType::DepthToSpace :
2068 {
2069 const armnn::DepthToSpaceDescriptor& layerDescriptor =
2070 static_cast<const armnn::DepthToSpaceDescriptor&>(descriptor);
2071 SerializeDepthToSpaceLayer(layer,
2072 layerDescriptor,
2073 name);
2074 break;
2075 }
2076 case armnn::LayerType::DepthwiseConvolution2d :
2077 {
2078 const armnn::DepthwiseConvolution2dDescriptor& layerDescriptor =
2079 static_cast<const armnn::DepthwiseConvolution2dDescriptor&>(descriptor);
2080 SerializeDepthwiseConvolution2dLayer(layer,
2081 layerDescriptor,
2082 constants,
2083 name);
2084 break;
2085 }
2086 case armnn::LayerType::Dequantize :
2087 {
2088 SerializeDequantizeLayer(layer,
2089 name);
2090 break;
2091 }
2092 case armnn::LayerType::DetectionPostProcess :
2093 {
2094 const armnn::DetectionPostProcessDescriptor& layerDescriptor =
2095 static_cast<const armnn::DetectionPostProcessDescriptor&>(descriptor);
2096 SerializeDetectionPostProcessLayer(layer, layerDescriptor, constants, name);
2097 break;
2098 }
2099 case armnn::LayerType::Division :
2100 {
2101 SerializeDivisionLayer(layer, name);
2102 break;
2103 }
2104 case armnn::LayerType::ElementwiseUnary :
2105 {
2106 const armnn::ElementwiseUnaryDescriptor& layerDescriptor =
2107 static_cast<const armnn::ElementwiseUnaryDescriptor&>(descriptor);
2108 SerializeElementwiseUnaryLayer(layer, layerDescriptor, name);
2109 break;
2110 }
2111 case armnn::LayerType::Fill :
2112 {
2113 const armnn::FillDescriptor& layerDescriptor =
2114 static_cast<const armnn::FillDescriptor&>(descriptor);
2115 SerializeFillLayer(layer, layerDescriptor, name);
2116 break;
2117 }
2118 case armnn::LayerType::Floor :
2119 {
2120 SerializeFloorLayer(layer, name);
2121 break;
2122 }
2123 case armnn::LayerType::FullyConnected :
2124 {
2125 const armnn::FullyConnectedDescriptor& layerDescriptor =
2126 static_cast<const armnn::FullyConnectedDescriptor&>(descriptor);
Matthew Sloyan81beae32021-07-13 19:46:11 +01002127 SerializeFullyConnectedLayer(layer, layerDescriptor, name);
Finn Williamsb454c5c2021-02-09 15:56:23 +00002128 break;
2129 }
2130 case armnn::LayerType::Gather :
2131 {
2132 const armnn::GatherDescriptor& layerDescriptor =
2133 static_cast<const armnn::GatherDescriptor&>(descriptor);
2134 SerializeGatherLayer(layer, layerDescriptor, name);
2135 break;
2136 }
2137 case armnn::LayerType::Input:
2138 {
2139 SerializeInputLayer(layer, id, name);
2140 break;
2141 }
2142 case armnn::LayerType::InstanceNormalization :
2143 {
2144 const armnn::InstanceNormalizationDescriptor& layerDescriptor =
2145 static_cast<const armnn::InstanceNormalizationDescriptor&>(descriptor);
2146 SerializeInstanceNormalizationLayer(layer, layerDescriptor, name);
2147 break;
2148 }
2149 case armnn::LayerType::L2Normalization :
2150 {
2151 const armnn::L2NormalizationDescriptor& layerDescriptor =
2152 static_cast<const armnn::L2NormalizationDescriptor&>(descriptor);
2153 SerializeL2NormalizationLayer(layer, layerDescriptor, name);
2154 break;
2155 }
2156 case armnn::LayerType::LogicalBinary :
2157 {
2158 const armnn::LogicalBinaryDescriptor& layerDescriptor =
2159 static_cast<const armnn::LogicalBinaryDescriptor&>(descriptor);
2160 SerializeLogicalBinaryLayer(layer, layerDescriptor, name);
2161 break;
2162 }
2163 case armnn::LayerType::LogSoftmax :
2164 {
2165 const armnn::LogSoftmaxDescriptor& layerDescriptor =
2166 static_cast<const armnn::LogSoftmaxDescriptor&>(descriptor);
2167 SerializeLogSoftmaxLayer(layer, layerDescriptor, name);
2168 break;
2169 }
2170 case armnn::LayerType::Lstm :
2171 {
2172 const armnn::LstmDescriptor& layerDescriptor =
2173 static_cast<const armnn::LstmDescriptor&>(descriptor);
2174 SerializeLstmLayer(layer, layerDescriptor, constants, name);
2175 break;
2176 }
2177 case armnn::LayerType::QLstm :
2178 {
2179 const armnn::QLstmDescriptor& layerDescriptor =
2180 static_cast<const armnn::QLstmDescriptor&>(descriptor);
2181 SerializeQLstmLayer(layer, layerDescriptor, constants, name);
2182 break;
2183 }
2184 case armnn::LayerType::Maximum :
2185 {
2186 SerializeMaximumLayer(layer, name);
2187 break;
2188 }
2189 case armnn::LayerType::Mean :
2190 {
2191 const armnn::MeanDescriptor& layerDescriptor =
2192 static_cast<const armnn::MeanDescriptor&>(descriptor);
2193 SerializeMeanLayer(layer, layerDescriptor, name);
2194 break;
2195 }
2196 case armnn::LayerType::Merge :
2197 {
2198 SerializeMergeLayer(layer, name);
2199 break;
2200 }
2201 case armnn::LayerType::Minimum :
2202 {
2203 SerializeMinimumLayer(layer, name);
2204 break;
2205 }
2206 case armnn::LayerType::Multiplication :
2207 {
2208 SerializeMultiplicationLayer(layer, name);
2209 break;
2210 }
2211 case armnn::LayerType::Normalization :
2212 {
2213 const armnn::NormalizationDescriptor& layerDescriptor =
2214 static_cast<const armnn::NormalizationDescriptor&>(descriptor);
2215 SerializeNormalizationLayer(layer, layerDescriptor, name);
2216 break;
2217 }
2218 case armnn::LayerType::Output:
2219 {
2220 SerializeOutputLayer(layer, id, name);
2221 break;
2222 }
2223 case armnn::LayerType::Pad :
2224 {
2225 const armnn::PadDescriptor& layerDescriptor =
2226 static_cast<const armnn::PadDescriptor&>(descriptor);
2227 SerializePadLayer(layer, layerDescriptor, name);
2228 break;
2229 }
2230 case armnn::LayerType::Permute :
2231 {
2232 const armnn::PermuteDescriptor& layerDescriptor =
2233 static_cast<const armnn::PermuteDescriptor&>(descriptor);
2234 SerializePermuteLayer(layer, layerDescriptor, name);
2235 break;
2236 }
2237 case armnn::LayerType::Pooling2d :
2238 {
2239 const armnn::Pooling2dDescriptor& layerDescriptor =
2240 static_cast<const armnn::Pooling2dDescriptor&>(descriptor);
2241 SerializePooling2dLayer(layer, layerDescriptor, name);
2242 break;
2243 }
Tamas Nyirid998a1c2021-11-05 14:55:33 +00002244 case armnn::LayerType::Pooling3d :
2245 {
2246 const armnn::Pooling3dDescriptor& layerDescriptor =
2247 static_cast<const armnn::Pooling3dDescriptor&>(descriptor);
2248 SerializePooling3dLayer(layer, layerDescriptor, name);
2249 break;
2250 }
Finn Williamsb454c5c2021-02-09 15:56:23 +00002251 case armnn::LayerType::Prelu :
2252 {
2253 SerializePreluLayer(layer, name);
2254 break;
2255 }
2256 case armnn::LayerType::Quantize :
2257 {
2258 SerializeQuantizeLayer(layer, name);
2259 break;
2260 }
2261 case armnn::LayerType::QuantizedLstm:
2262 SerializeQuantizedLstmLayer(layer, constants, name);
2263 break;
2264 case armnn::LayerType::Reshape:
2265 {
2266 const armnn::ReshapeDescriptor &layerDescriptor =
2267 static_cast<const armnn::ReshapeDescriptor &>(descriptor);
2268 SerializeReshapeLayer(layer, layerDescriptor, name);
2269 break;
2270 }
2271 case armnn::LayerType::Rank:
2272 {
2273 SerializeRankLayer(layer, name);
2274 break;
2275 }
2276 case armnn::LayerType::Reduce:
2277 {
2278 const armnn::ReduceDescriptor& layerDescriptor =
2279 static_cast<const armnn::ReduceDescriptor&>(descriptor);
2280 SerializeReduceLayer(layer, layerDescriptor, name);
2281 break;
2282 }
2283 case armnn::LayerType::Resize:
2284 {
2285 const armnn::ResizeDescriptor& layerDescriptor =
2286 static_cast<const armnn::ResizeDescriptor&>(descriptor);
2287 SerializeResizeLayer(layer, layerDescriptor, name);
2288 break;
2289 }
Keith Davis3ae3f972021-05-21 16:33:48 +01002290 case armnn::LayerType::Shape:
2291 {
2292 SerializeShapeLayer(layer, name);
2293 break;
2294 }
Finn Williamsb454c5c2021-02-09 15:56:23 +00002295 case armnn::LayerType::Slice:
2296 {
2297 const armnn::SliceDescriptor& layerDescriptor =
2298 static_cast<const armnn::SliceDescriptor&>(descriptor);
2299 SerializeSliceLayer(layer, layerDescriptor, name);
2300 break;
2301 }
2302 case armnn::LayerType::Softmax:
2303 {
2304 const armnn::SoftmaxDescriptor& layerDescriptor =
2305 static_cast<const armnn::SoftmaxDescriptor&>(descriptor);
2306 SerializeSoftmaxLayer(layer, layerDescriptor, name);
2307 break;
2308 }
2309 case armnn::LayerType::SpaceToBatchNd:
2310 {
2311 const armnn::SpaceToBatchNdDescriptor& layerDescriptor =
2312 static_cast<const armnn::SpaceToBatchNdDescriptor&>(descriptor);
2313 SerializeSpaceToBatchNdLayer(layer, layerDescriptor, name);
2314 break;
2315 }
2316 case armnn::LayerType::SpaceToDepth:
2317 {
2318 const armnn::SpaceToDepthDescriptor& layerDescriptor =
2319 static_cast<const armnn::SpaceToDepthDescriptor&>(descriptor);
2320 SerializeSpaceToDepthLayer(layer, layerDescriptor, name);
2321 break;
2322 }
2323 case armnn::LayerType::Splitter:
2324 {
2325 const armnn::SplitterDescriptor& layerDescriptor =
2326 static_cast<const armnn::SplitterDescriptor&>(descriptor);
2327 SerializeSplitterLayer(layer, layerDescriptor, name);
2328 break;
2329 }
2330 case armnn::LayerType::Stack:
2331 {
2332 const armnn::StackDescriptor& layerDescriptor =
2333 static_cast<const armnn::StackDescriptor&>(descriptor);
2334 SerializeStackLayer(layer, layerDescriptor, name);
2335 break;
2336 }
2337 case armnn::LayerType::StandIn:
2338 {
2339 const armnn::StandInDescriptor& layerDescriptor =
2340 static_cast<const armnn::StandInDescriptor&>(descriptor);
2341 SerializeStandInLayer(layer, layerDescriptor, name);
2342 break;
2343 }
2344 case armnn::LayerType::StridedSlice:
2345 {
2346 const armnn::StridedSliceDescriptor& layerDescriptor =
2347 static_cast<const armnn::StridedSliceDescriptor&>(descriptor);
2348 SerializeStridedSliceLayer(layer, layerDescriptor, name);
2349 break;
2350 }
2351 case armnn::LayerType::Subtraction:
2352 {
2353 SerializeSubtractionLayer(layer, name);
2354 break;
2355 }
2356 case armnn::LayerType::Switch:
2357 {
2358 SerializeSwitchLayer(layer, name);
2359 break;
2360 }
2361 case armnn::LayerType::Transpose:
2362 {
2363 const armnn::TransposeDescriptor& layerDescriptor =
2364 static_cast<const armnn::TransposeDescriptor&>(descriptor);
2365 SerializeTransposeLayer(layer, layerDescriptor, name);
2366 break;
2367 }
2368 case armnn::LayerType::TransposeConvolution2d:
2369 {
2370 const armnn::TransposeConvolution2dDescriptor& layerDescriptor =
2371 static_cast<const armnn::TransposeConvolution2dDescriptor&>(descriptor);
2372 SerializeTransposeConvolution2dLayer(layer, layerDescriptor, constants, name);
2373 break;
2374 }
Narumol Prangnawarata0162e12021-07-23 14:47:49 +01002375 case armnn::LayerType::UnidirectionalSequenceLstm :
2376 {
2377 const armnn::UnidirectionalSequenceLstmDescriptor& layerDescriptor =
2378 static_cast<const armnn::UnidirectionalSequenceLstmDescriptor&>(descriptor);
2379 SerializeUnidirectionalSequenceLstmLayer(layer, layerDescriptor, constants, name);
2380 break;
2381 }
Finn Williamsb454c5c2021-02-09 15:56:23 +00002382 default:
2383 {
2384 throw InvalidArgumentException(
2385 fmt::format("A layer of unknown type was given to the serializer. Layer name: {}; Layer Id: {}",
2386 layer->GetName(),
2387 id));
2388 }
2389 }
2390}
2391
Finn Williams85d36712021-01-26 22:30:06 +00002392void ISerializer::SerializerImpl::Serialize(const INetwork& inNetwork)
Nattapat Chaimanowongac9cadc2019-02-13 15:52:41 +00002393{
2394 // Iterate through to network
Finn Williamsb454c5c2021-02-09 15:56:23 +00002395 inNetwork.ExecuteStrategy(m_SerializerStrategy);
2396 flatbuffers::FlatBufferBuilder& fbBuilder = m_SerializerStrategy.GetFlatBufferBuilder();
Nattapat Chaimanowongac9cadc2019-02-13 15:52:41 +00002397
2398 // Create FlatBuffer SerializedGraph
2399 auto serializedGraph = serializer::CreateSerializedGraph(
Finn Williamsb454c5c2021-02-09 15:56:23 +00002400 fbBuilder,
2401 fbBuilder.CreateVector(m_SerializerStrategy.GetSerializedLayers()),
2402 fbBuilder.CreateVector(m_SerializerStrategy.GetInputIds()),
2403 fbBuilder.CreateVector(m_SerializerStrategy.GetOutputIds()),
2404 m_SerializerStrategy.GetVersionTable());
Nattapat Chaimanowongac9cadc2019-02-13 15:52:41 +00002405
2406 // Serialize the graph
2407 fbBuilder.Finish(serializedGraph);
2408}
2409
Finn Williamsb454c5c2021-02-09 15:56:23 +00002410
Finn Williams85d36712021-01-26 22:30:06 +00002411bool ISerializer::SerializerImpl::SaveSerializedToStream(std::ostream& stream)
Nattapat Chaimanowongac9cadc2019-02-13 15:52:41 +00002412{
Finn Williamsb454c5c2021-02-09 15:56:23 +00002413 flatbuffers::FlatBufferBuilder& fbBuilder = m_SerializerStrategy.GetFlatBufferBuilder();
Nattapat Chaimanowongac9cadc2019-02-13 15:52:41 +00002414
Matthew Sloyan0663d662020-09-14 11:47:26 +01002415 auto bytesToWrite = armnn::numeric_cast<std::streamsize>(fbBuilder.GetSize());
Nattapat Chaimanowong7b53b692019-02-12 14:38:31 +00002416 stream.write(reinterpret_cast<const char*>(fbBuilder.GetBufferPointer()), bytesToWrite);
Nattapat Chaimanowongac9cadc2019-02-13 15:52:41 +00002417 return !stream.bad();
2418}
2419
Finn Williams2605b232020-06-10 15:53:46 +01002420} // namespace armnnSerializer